support/map.c

   1 /*
   2  * This file was automatically generated by create-native-map from ../../mcs/class/lib/net_2_0/Mono.Posix.dll.
   3  *
   4  * DO NOT MODIFY.
   5  */
   6 #ifdef HAVE_CONFIG_H
   7 #include <config.h>
   8 #endif /* ndef HAVE_CONFIG_H */
   9
  10 #include <stdlib.h>
  11 #include <string.h>
  12
  13 /*
  14  * Implementation Macros
  15  */
  16 #ifndef _GNU_SOURCE
  17 #define _GNU_SOURCE
  18 #endif /* ndef _GNU_SOURCE */
  19
  20 #ifndef _XOPEN_SOURCE
  21 #define _XOPEN_SOURCE
  22 #endif /* ndef _XOPEN_SOURCE */
  23
  24
  25 /*
  26  * Implementation Includes
  27  */
  28 #include <sys/types.h>
  29 #include <sys/stat.h>
  30 #include <sys/time.h>
  31 #ifdef HAVE_SYS_POLL_H
  32 #include <sys/poll.h>
  33 #endif /* ndef HAVE_SYS_POLL_H */
  34 #ifdef HAVE_SYS_WAIT_H
  35 #include <sys/wait.h>
  36 #endif /* ndef HAVE_SYS_WAIT_H */
  37 #ifdef HAVE_SYS_STATVFS_H
  38 #include <sys/statvfs.h>
  39 #endif /* ndef HAVE_SYS_STATVFS_H */
  40 #ifdef HAVE_SYS_XATTR_H
  41 #include <sys/xattr.h>
  42 #endif /* ndef HAVE_SYS_XATTR_H */
  43 #ifdef HAVE_SYS_MMAN_H
  44 #include <sys/mman.h>
  45 #endif /* ndef HAVE_SYS_MMAN_H */
  46 #include <unistd.h>
  47 #include <fcntl.h>
  48 #include <signal.h>
  49 #ifdef HAVE_POLL_H
  50 #include <poll.h>
  51 #endif /* ndef HAVE_POLL_H */
  52 #ifdef HAVE_GRP_H
  53 #include <grp.h>
  54 #endif /* ndef HAVE_GRP_H */
  55 #include <errno.h>
  56 #ifdef HAVE_SYSLOG_H
  57 #include <syslog.h>
  58 #endif /* ndef HAVE_SYSLOG_H */
  59 #include <dirent.h>
  60 #include <utime.h>
  61 #include "mph.h"
  62
  63 #include "map.h"
  64
  65 #include <errno.h>    /* errno, EOVERFLOW */
  66 #include <glib.h>     /* g* types, g_assert_not_reached() */
  67
  68 /* returns TRUE if @type is an unsigned type */
  69 #define _cnm_integral_type_is_unsigned(type) \
  70     (sizeof(type) == sizeof(gint8)           \
  71       ? (((type)-1) > G_MAXINT8)             \
  72       : sizeof(type) == sizeof(gint16)       \
  73         ? (((type)-1) > G_MAXINT16)          \
  74         : sizeof(type) == sizeof(gint32)     \
  75           ? (((type)-1) > G_MAXINT32)        \
  76           : sizeof(type) == sizeof(gint64)   \
  77             ? (((type)-1) > G_MAXINT64)      \
  78             : (g_assert_not_reached (), 0))
  79
  80 /* returns the minimum value of @type as a gint64 */
  81 #define _cnm_integral_type_min(type)          \
  82     (_cnm_integral_type_is_unsigned (type)    \
  83       ? 0                                     \
  84       : sizeof(type) == sizeof(gint8)         \
  85         ? G_MININT8                           \
  86         : sizeof(type) == sizeof(gint16)      \
  87           ? G_MININT16                        \
  88           : sizeof(type) == sizeof(gint32)    \
  89             ? G_MININT32                      \
  90             : sizeof(type) == sizeof(gint64)  \
  91               ? G_MININT64                    \
  92               : (g_assert_not_reached (), 0))
  93
  94 /* returns the maximum value of @type as a guint64 */
  95 #define _cnm_integral_type_max(type)            \
  96     (_cnm_integral_type_is_unsigned (type)      \
  97       ? sizeof(type) == sizeof(gint8)           \
  98         ? G_MAXUINT8                            \
  99         : sizeof(type) == sizeof(gint16)        \
 100           ? G_MAXUINT16                         \
 101           : sizeof(type) == sizeof(gint32)      \
 102             ? G_MAXUINT32                       \
 103             : sizeof(type) == sizeof(gint64)    \
 104               ? G_MAXUINT64                     \
 105               : (g_assert_not_reached (), 0)    \
 106       : sizeof(type) == sizeof(gint8)           \
 107           ? G_MAXINT8                           \
 108           : sizeof(type) == sizeof(gint16)      \
 109             ? G_MAXINT16                        \
 110             : sizeof(type) == sizeof(gint32)    \
 111               ? G_MAXINT32                      \
 112               : sizeof(type) == sizeof(gint64)  \
 113                 ? G_MAXINT64                    \
 114                 : (g_assert_not_reached (), 0))
 115
 116 #ifdef DEBUG
 117 #define _cnm_dump_(to_t,from)                                            \
 118   printf ("# %s -> %s: min=%llx; max=%llx; value=%llx; lt=%i; l0=%i; gt=%i; e=%i\n", \
 119     #from, #to_t,                                                        \
 120     (gint64) (_cnm_integral_type_min(to_t)),                             \
 121     (gint64) (_cnm_integral_type_max (to_t)),                            \
 122     (gint64) (from),                                                     \
 123     (_cnm_integral_type_min (to_t) <= from),                             \
 124     (from < 0),                                                          \
 125     /* (_cnm_integral_type_max (to_t) >= from) */                        \
 126     (from <= _cnm_integral_type_max (to_t)),                             \
 127     ((_cnm_integral_type_min(to_t) >= from) &&                           \
 128           ((from < 0) ? 1 : (from <= _cnm_integral_type_max(to_t))))     \
 129   )
 130 #else
 131 #define _cnm_dump_(to_t, from) do {} while (0)
 132 #endif
 133
 134 #define _cnm_return_val_if_overflow(to_t,from,val)  G_STMT_START {   \
 135     if (!(_cnm_integral_type_min(to_t) <= from &&                    \
 136           ((from < 0) || (from <= _cnm_integral_type_max(to_t))))) { \
 137       _cnm_dump_(to_t, from);                                        \
 138       errno = EOVERFLOW;                                             \
 139       return (val);                                                  \
 140     }                                                                \
 141   } G_STMT_END
 142
 143 int Mono_Posix_FromAccessModes (int x, int *r)
 144 {
 145         *r = 0;
 146         if ((x & Mono_Posix_AccessModes_F_OK) == Mono_Posix_AccessModes_F_OK)
 147 #ifdef F_OK
 148                 *r |= F_OK;
 149 #else /* def F_OK */
 150                 {errno = EINVAL; return -1;}
 151 #endif /* ndef F_OK */
 152         if ((x & Mono_Posix_AccessModes_R_OK) == Mono_Posix_AccessModes_R_OK)
 153 #ifdef R_OK
 154                 *r |= R_OK;
 155 #else /* def R_OK */
 156                 {errno = EINVAL; return -1;}
 157 #endif /* ndef R_OK */
 158         if ((x & Mono_Posix_AccessModes_W_OK) == Mono_Posix_AccessModes_W_OK)
 159 #ifdef W_OK
 160                 *r |= W_OK;
 161 #else /* def W_OK */
 162                 {errno = EINVAL; return -1;}
 163 #endif /* ndef W_OK */
 164         if ((x & Mono_Posix_AccessModes_X_OK) == Mono_Posix_AccessModes_X_OK)
 165 #ifdef X_OK
 166                 *r |= X_OK;
 167 #else /* def X_OK */
 168                 {errno = EINVAL; return -1;}
 169 #endif /* ndef X_OK */
 170         if (x == 0)
 171                 return 0;
 172         return 0;
 173 }
 174
 175 int Mono_Posix_ToAccessModes (int x, int *r)
 176 {
 177         *r = 0;
 178         if (x == 0)
 179                 return 0;
 180 #ifdef F_OK
 181         if ((x & F_OK) == F_OK)
 182                 *r |= Mono_Posix_AccessModes_F_OK;
 183 #endif /* ndef F_OK */
 184 #ifdef R_OK
 185         if ((x & R_OK) == R_OK)
 186                 *r |= Mono_Posix_AccessModes_R_OK;
 187 #endif /* ndef R_OK */
 188 #ifdef W_OK
 189         if ((x & W_OK) == W_OK)
 190                 *r |= Mono_Posix_AccessModes_W_OK;
 191 #endif /* ndef W_OK */
 192 #ifdef X_OK
 193         if ((x & X_OK) == X_OK)
 194                 *r |= Mono_Posix_AccessModes_X_OK;
 195 #endif /* ndef X_OK */
 196         return 0;
 197 }
 198
 199 int Mono_Posix_FromConfstrName (int x, int *r)
 200 {
 201         *r = 0;
 202         if (x == Mono_Posix_ConfstrName__CS_GNU_LIBC_VERSION)
 203 #ifdef _CS_GNU_LIBC_VERSION
 204                 {*r = _CS_GNU_LIBC_VERSION; return 0;}
 205 #else /* def _CS_GNU_LIBC_VERSION */
 206                 {errno = EINVAL; return -1;}
 207 #endif /* ndef _CS_GNU_LIBC_VERSION */
 208         if (x == Mono_Posix_ConfstrName__CS_GNU_LIBPTHREAD_VERSION)
 209 #ifdef _CS_GNU_LIBPTHREAD_VERSION
 210                 {*r = _CS_GNU_LIBPTHREAD_VERSION; return 0;}
 211 #else /* def _CS_GNU_LIBPTHREAD_VERSION */
 212                 {errno = EINVAL; return -1;}
 213 #endif /* ndef _CS_GNU_LIBPTHREAD_VERSION */
 214         if (x == Mono_Posix_ConfstrName__CS_LFS64_CFLAGS)
 215 #ifdef _CS_LFS64_CFLAGS
 216                 {*r = _CS_LFS64_CFLAGS; return 0;}
 217 #else /* def _CS_LFS64_CFLAGS */
 218                 {errno = EINVAL; return -1;}
 219 #endif /* ndef _CS_LFS64_CFLAGS */
 220         if (x == Mono_Posix_ConfstrName__CS_LFS64_LDFLAGS)
 221 #ifdef _CS_LFS64_LDFLAGS
 222                 {*r = _CS_LFS64_LDFLAGS; return 0;}
 223 #else /* def _CS_LFS64_LDFLAGS */
 224                 {errno = EINVAL; return -1;}
 225 #endif /* ndef _CS_LFS64_LDFLAGS */
 226         if (x == Mono_Posix_ConfstrName__CS_LFS64_LIBS)
 227 #ifdef _CS_LFS64_LIBS
 228                 {*r = _CS_LFS64_LIBS; return 0;}
 229 #else /* def _CS_LFS64_LIBS */
 230                 {errno = EINVAL; return -1;}
 231 #endif /* ndef _CS_LFS64_LIBS */
 232         if (x == Mono_Posix_ConfstrName__CS_LFS64_LINTFLAGS)
 233 #ifdef _CS_LFS64_LINTFLAGS
 234                 {*r = _CS_LFS64_LINTFLAGS; return 0;}
 235 #else /* def _CS_LFS64_LINTFLAGS */
 236                 {errno = EINVAL; return -1;}
 237 #endif /* ndef _CS_LFS64_LINTFLAGS */
 238         if (x == Mono_Posix_ConfstrName__CS_LFS_CFLAGS)
 239 #ifdef _CS_LFS_CFLAGS
 240                 {*r = _CS_LFS_CFLAGS; return 0;}
 241 #else /* def _CS_LFS_CFLAGS */
 242                 {errno = EINVAL; return -1;}
 243 #endif /* ndef _CS_LFS_CFLAGS */
 244         if (x == Mono_Posix_ConfstrName__CS_LFS_LDFLAGS)
 245 #ifdef _CS_LFS_LDFLAGS
 246                 {*r = _CS_LFS_LDFLAGS; return 0;}
 247 #else /* def _CS_LFS_LDFLAGS */
 248                 {errno = EINVAL; return -1;}
 249 #endif /* ndef _CS_LFS_LDFLAGS */
 250         if (x == Mono_Posix_ConfstrName__CS_LFS_LIBS)
 251 #ifdef _CS_LFS_LIBS
 252                 {*r = _CS_LFS_LIBS; return 0;}
 253 #else /* def _CS_LFS_LIBS */
 254                 {errno = EINVAL; return -1;}
 255 #endif /* ndef _CS_LFS_LIBS */
 256         if (x == Mono_Posix_ConfstrName__CS_LFS_LINTFLAGS)
 257 #ifdef _CS_LFS_LINTFLAGS
 258                 {*r = _CS_LFS_LINTFLAGS; return 0;}
 259 #else /* def _CS_LFS_LINTFLAGS */
 260                 {errno = EINVAL; return -1;}
 261 #endif /* ndef _CS_LFS_LINTFLAGS */
 262         if (x == Mono_Posix_ConfstrName__CS_PATH)
 263 #ifdef _CS_PATH
 264                 {*r = _CS_PATH; return 0;}
 265 #else /* def _CS_PATH */
 266                 {errno = EINVAL; return -1;}
 267 #endif /* ndef _CS_PATH */
 268         if (x == Mono_Posix_ConfstrName__CS_POSIX_V6_ILP32_OFF32_CFLAGS)
 269 #ifdef _CS_POSIX_V6_ILP32_OFF32_CFLAGS
 270                 {*r = _CS_POSIX_V6_ILP32_OFF32_CFLAGS; return 0;}
 271 #else /* def _CS_POSIX_V6_ILP32_OFF32_CFLAGS */
 272                 {errno = EINVAL; return -1;}
 273 #endif /* ndef _CS_POSIX_V6_ILP32_OFF32_CFLAGS */
 274         if (x == Mono_Posix_ConfstrName__CS_POSIX_V6_ILP32_OFF32_LDFLAGS)
 275 #ifdef _CS_POSIX_V6_ILP32_OFF32_LDFLAGS
 276                 {*r = _CS_POSIX_V6_ILP32_OFF32_LDFLAGS; return 0;}
 277 #else /* def _CS_POSIX_V6_ILP32_OFF32_LDFLAGS */
 278                 {errno = EINVAL; return -1;}
 279 #endif /* ndef _CS_POSIX_V6_ILP32_OFF32_LDFLAGS */
 280         if (x == Mono_Posix_ConfstrName__CS_POSIX_V6_ILP32_OFF32_LIBS)
 281 #ifdef _CS_POSIX_V6_ILP32_OFF32_LIBS
 282                 {*r = _CS_POSIX_V6_ILP32_OFF32_LIBS; return 0;}
 283 #else /* def _CS_POSIX_V6_ILP32_OFF32_LIBS */
 284                 {errno = EINVAL; return -1;}
 285 #endif /* ndef _CS_POSIX_V6_ILP32_OFF32_LIBS */
 286         if (x == Mono_Posix_ConfstrName__CS_POSIX_V6_ILP32_OFF32_LINTFLAGS)
 287 #ifdef _CS_POSIX_V6_ILP32_OFF32_LINTFLAGS
 288                 {*r = _CS_POSIX_V6_ILP32_OFF32_LINTFLAGS; return 0;}
 289 #else /* def _CS_POSIX_V6_ILP32_OFF32_LINTFLAGS */
 290                 {errno = EINVAL; return -1;}
 291 #endif /* ndef _CS_POSIX_V6_ILP32_OFF32_LINTFLAGS */
 292         if (x == Mono_Posix_ConfstrName__CS_POSIX_V6_ILP32_OFFBIG_CFLAGS)
 293 #ifdef _CS_POSIX_V6_ILP32_OFFBIG_CFLAGS
 294                 {*r = _CS_POSIX_V6_ILP32_OFFBIG_CFLAGS; return 0;}
 295 #else /* def _CS_POSIX_V6_ILP32_OFFBIG_CFLAGS */
 296                 {errno = EINVAL; return -1;}
 297 #endif /* ndef _CS_POSIX_V6_ILP32_OFFBIG_CFLAGS */
 298         if (x == Mono_Posix_ConfstrName__CS_POSIX_V6_ILP32_OFFBIG_LDFLAGS)
 299 #ifdef _CS_POSIX_V6_ILP32_OFFBIG_LDFLAGS
 300                 {*r = _CS_POSIX_V6_ILP32_OFFBIG_LDFLAGS; return 0;}
 301 #else /* def _CS_POSIX_V6_ILP32_OFFBIG_LDFLAGS */
 302                 {errno = EINVAL; return -1;}
 303 #endif /* ndef _CS_POSIX_V6_ILP32_OFFBIG_LDFLAGS */
 304         if (x == Mono_Posix_ConfstrName__CS_POSIX_V6_ILP32_OFFBIG_LIBS)
 305 #ifdef _CS_POSIX_V6_ILP32_OFFBIG_LIBS
 306                 {*r = _CS_POSIX_V6_ILP32_OFFBIG_LIBS; return 0;}
 307 #else /* def _CS_POSIX_V6_ILP32_OFFBIG_LIBS */
 308                 {errno = EINVAL; return -1;}
 309 #endif /* ndef _CS_POSIX_V6_ILP32_OFFBIG_LIBS */
 310         if (x == Mono_Posix_ConfstrName__CS_POSIX_V6_ILP32_OFFBIG_LINTFLAGS)
 311 #ifdef _CS_POSIX_V6_ILP32_OFFBIG_LINTFLAGS
 312                 {*r = _CS_POSIX_V6_ILP32_OFFBIG_LINTFLAGS; return 0;}
 313 #else /* def _CS_POSIX_V6_ILP32_OFFBIG_LINTFLAGS */
 314                 {errno = EINVAL; return -1;}
 315 #endif /* ndef _CS_POSIX_V6_ILP32_OFFBIG_LINTFLAGS */
 316         if (x == Mono_Posix_ConfstrName__CS_POSIX_V6_LP64_OFF64_CFLAGS)
 317 #ifdef _CS_POSIX_V6_LP64_OFF64_CFLAGS
 318                 {*r = _CS_POSIX_V6_LP64_OFF64_CFLAGS; return 0;}
 319 #else /* def _CS_POSIX_V6_LP64_OFF64_CFLAGS */
 320                 {errno = EINVAL; return -1;}
 321 #endif /* ndef _CS_POSIX_V6_LP64_OFF64_CFLAGS */
 322         if (x == Mono_Posix_ConfstrName__CS_POSIX_V6_LP64_OFF64_LDFLAGS)
 323 #ifdef _CS_POSIX_V6_LP64_OFF64_LDFLAGS
 324                 {*r = _CS_POSIX_V6_LP64_OFF64_LDFLAGS; return 0;}
 325 #else /* def _CS_POSIX_V6_LP64_OFF64_LDFLAGS */
 326                 {errno = EINVAL; return -1;}
 327 #endif /* ndef _CS_POSIX_V6_LP64_OFF64_LDFLAGS */
 328         if (x == Mono_Posix_ConfstrName__CS_POSIX_V6_LP64_OFF64_LIBS)
 329 #ifdef _CS_POSIX_V6_LP64_OFF64_LIBS
 330                 {*r = _CS_POSIX_V6_LP64_OFF64_LIBS; return 0;}
 331 #else /* def _CS_POSIX_V6_LP64_OFF64_LIBS */
 332                 {errno = EINVAL; return -1;}
 333 #endif /* ndef _CS_POSIX_V6_LP64_OFF64_LIBS */
 334         if (x == Mono_Posix_ConfstrName__CS_POSIX_V6_LP64_OFF64_LINTFLAGS)
 335 #ifdef _CS_POSIX_V6_LP64_OFF64_LINTFLAGS
 336                 {*r = _CS_POSIX_V6_LP64_OFF64_LINTFLAGS; return 0;}
 337 #else /* def _CS_POSIX_V6_LP64_OFF64_LINTFLAGS */
 338                 {errno = EINVAL; return -1;}
 339 #endif /* ndef _CS_POSIX_V6_LP64_OFF64_LINTFLAGS */
 340         if (x == Mono_Posix_ConfstrName__CS_POSIX_V6_LPBIG_OFFBIG_CFLAGS)
 341 #ifdef _CS_POSIX_V6_LPBIG_OFFBIG_CFLAGS
 342                 {*r = _CS_POSIX_V6_LPBIG_OFFBIG_CFLAGS; return 0;}
 343 #else /* def _CS_POSIX_V6_LPBIG_OFFBIG_CFLAGS */
 344                 {errno = EINVAL; return -1;}
 345 #endif /* ndef _CS_POSIX_V6_LPBIG_OFFBIG_CFLAGS */
 346         if (x == Mono_Posix_ConfstrName__CS_POSIX_V6_LPBIG_OFFBIG_LDFLAGS)
 347 #ifdef _CS_POSIX_V6_LPBIG_OFFBIG_LDFLAGS
 348                 {*r = _CS_POSIX_V6_LPBIG_OFFBIG_LDFLAGS; return 0;}
 349 #else /* def _CS_POSIX_V6_LPBIG_OFFBIG_LDFLAGS */
 350                 {errno = EINVAL; return -1;}
 351 #endif /* ndef _CS_POSIX_V6_LPBIG_OFFBIG_LDFLAGS */
 352         if (x == Mono_Posix_ConfstrName__CS_POSIX_V6_LPBIG_OFFBIG_LIBS)
 353 #ifdef _CS_POSIX_V6_LPBIG_OFFBIG_LIBS
 354                 {*r = _CS_POSIX_V6_LPBIG_OFFBIG_LIBS; return 0;}
 355 #else /* def _CS_POSIX_V6_LPBIG_OFFBIG_LIBS */
 356                 {errno = EINVAL; return -1;}
 357 #endif /* ndef _CS_POSIX_V6_LPBIG_OFFBIG_LIBS */
 358         if (x == Mono_Posix_ConfstrName__CS_POSIX_V6_LPBIG_OFFBIG_LINTFLAGS)
 359 #ifdef _CS_POSIX_V6_LPBIG_OFFBIG_LINTFLAGS
 360                 {*r = _CS_POSIX_V6_LPBIG_OFFBIG_LINTFLAGS; return 0;}
 361 #else /* def _CS_POSIX_V6_LPBIG_OFFBIG_LINTFLAGS */
 362                 {errno = EINVAL; return -1;}
 363 #endif /* ndef _CS_POSIX_V6_LPBIG_OFFBIG_LINTFLAGS */
 364         if (x == Mono_Posix_ConfstrName__CS_V6_WIDTH_RESTRICTED_ENVS)
 365 #ifdef _CS_V6_WIDTH_RESTRICTED_ENVS
 366                 {*r = _CS_V6_WIDTH_RESTRICTED_ENVS; return 0;}
 367 #else /* def _CS_V6_WIDTH_RESTRICTED_ENVS */
 368                 {errno = EINVAL; return -1;}
 369 #endif /* ndef _CS_V6_WIDTH_RESTRICTED_ENVS */
 370         if (x == Mono_Posix_ConfstrName__CS_XBS5_ILP32_OFF32_CFLAGS)
 371 #ifdef _CS_XBS5_ILP32_OFF32_CFLAGS
 372                 {*r = _CS_XBS5_ILP32_OFF32_CFLAGS; return 0;}
 373 #else /* def _CS_XBS5_ILP32_OFF32_CFLAGS */
 374                 {errno = EINVAL; return -1;}
 375 #endif /* ndef _CS_XBS5_ILP32_OFF32_CFLAGS */
 376         if (x == Mono_Posix_ConfstrName__CS_XBS5_ILP32_OFF32_LDFLAGS)
 377 #ifdef _CS_XBS5_ILP32_OFF32_LDFLAGS
 378                 {*r = _CS_XBS5_ILP32_OFF32_LDFLAGS; return 0;}
 379 #else /* def _CS_XBS5_ILP32_OFF32_LDFLAGS */
 380                 {errno = EINVAL; return -1;}
 381 #endif /* ndef _CS_XBS5_ILP32_OFF32_LDFLAGS */
 382         if (x == Mono_Posix_ConfstrName__CS_XBS5_ILP32_OFF32_LIBS)
 383 #ifdef _CS_XBS5_ILP32_OFF32_LIBS
 384                 {*r = _CS_XBS5_ILP32_OFF32_LIBS; return 0;}
 385 #else /* def _CS_XBS5_ILP32_OFF32_LIBS */
 386                 {errno = EINVAL; return -1;}
 387 #endif /* ndef _CS_XBS5_ILP32_OFF32_LIBS */
 388         if (x == Mono_Posix_ConfstrName__CS_XBS5_ILP32_OFF32_LINTFLAGS)
 389 #ifdef _CS_XBS5_ILP32_OFF32_LINTFLAGS
 390                 {*r = _CS_XBS5_ILP32_OFF32_LINTFLAGS; return 0;}
 391 #else /* def _CS_XBS5_ILP32_OFF32_LINTFLAGS */
 392                 {errno = EINVAL; return -1;}
 393 #endif /* ndef _CS_XBS5_ILP32_OFF32_LINTFLAGS */
 394         if (x == Mono_Posix_ConfstrName__CS_XBS5_ILP32_OFFBIG_CFLAGS)
 395 #ifdef _CS_XBS5_ILP32_OFFBIG_CFLAGS
 396                 {*r = _CS_XBS5_ILP32_OFFBIG_CFLAGS; return 0;}
 397 #else /* def _CS_XBS5_ILP32_OFFBIG_CFLAGS */
 398                 {errno = EINVAL; return -1;}
 399 #endif /* ndef _CS_XBS5_ILP32_OFFBIG_CFLAGS */
 400         if (x == Mono_Posix_ConfstrName__CS_XBS5_ILP32_OFFBIG_LDFLAGS)
 401 #ifdef _CS_XBS5_ILP32_OFFBIG_LDFLAGS
 402                 {*r = _CS_XBS5_ILP32_OFFBIG_LDFLAGS; return 0;}
 403 #else /* def _CS_XBS5_ILP32_OFFBIG_LDFLAGS */
 404                 {errno = EINVAL; return -1;}
 405 #endif /* ndef _CS_XBS5_ILP32_OFFBIG_LDFLAGS */
 406         if (x == Mono_Posix_ConfstrName__CS_XBS5_ILP32_OFFBIG_LIBS)
 407 #ifdef _CS_XBS5_ILP32_OFFBIG_LIBS
 408                 {*r = _CS_XBS5_ILP32_OFFBIG_LIBS; return 0;}
 409 #else /* def _CS_XBS5_ILP32_OFFBIG_LIBS */
 410                 {errno = EINVAL; return -1;}
 411 #endif /* ndef _CS_XBS5_ILP32_OFFBIG_LIBS */
 412         if (x == Mono_Posix_ConfstrName__CS_XBS5_ILP32_OFFBIG_LINTFLAGS)
 413 #ifdef _CS_XBS5_ILP32_OFFBIG_LINTFLAGS
 414                 {*r = _CS_XBS5_ILP32_OFFBIG_LINTFLAGS; return 0;}
 415 #else /* def _CS_XBS5_ILP32_OFFBIG_LINTFLAGS */
 416                 {errno = EINVAL; return -1;}
 417 #endif /* ndef _CS_XBS5_ILP32_OFFBIG_LINTFLAGS */
 418         if (x == Mono_Posix_ConfstrName__CS_XBS5_LP64_OFF64_CFLAGS)
 419 #ifdef _CS_XBS5_LP64_OFF64_CFLAGS
 420                 {*r = _CS_XBS5_LP64_OFF64_CFLAGS; return 0;}
 421 #else /* def _CS_XBS5_LP64_OFF64_CFLAGS */
 422                 {errno = EINVAL; return -1;}
 423 #endif /* ndef _CS_XBS5_LP64_OFF64_CFLAGS */
 424         if (x == Mono_Posix_ConfstrName__CS_XBS5_LP64_OFF64_LDFLAGS)
 425 #ifdef _CS_XBS5_LP64_OFF64_LDFLAGS
 426                 {*r = _CS_XBS5_LP64_OFF64_LDFLAGS; return 0;}
 427 #else /* def _CS_XBS5_LP64_OFF64_LDFLAGS */
 428                 {errno = EINVAL; return -1;}
 429 #endif /* ndef _CS_XBS5_LP64_OFF64_LDFLAGS */
 430         if (x == Mono_Posix_ConfstrName__CS_XBS5_LP64_OFF64_LIBS)
 431 #ifdef _CS_XBS5_LP64_OFF64_LIBS
 432                 {*r = _CS_XBS5_LP64_OFF64_LIBS; return 0;}
 433 #else /* def _CS_XBS5_LP64_OFF64_LIBS */
 434                 {errno = EINVAL; return -1;}
 435 #endif /* ndef _CS_XBS5_LP64_OFF64_LIBS */
 436         if (x == Mono_Posix_ConfstrName__CS_XBS5_LP64_OFF64_LINTFLAGS)
 437 #ifdef _CS_XBS5_LP64_OFF64_LINTFLAGS
 438                 {*r = _CS_XBS5_LP64_OFF64_LINTFLAGS; return 0;}
 439 #else /* def _CS_XBS5_LP64_OFF64_LINTFLAGS */
 440                 {errno = EINVAL; return -1;}
 441 #endif /* ndef _CS_XBS5_LP64_OFF64_LINTFLAGS */
 442         if (x == Mono_Posix_ConfstrName__CS_XBS5_LPBIG_OFFBIG_CFLAGS)
 443 #ifdef _CS_XBS5_LPBIG_OFFBIG_CFLAGS
 444                 {*r = _CS_XBS5_LPBIG_OFFBIG_CFLAGS; return 0;}
 445 #else /* def _CS_XBS5_LPBIG_OFFBIG_CFLAGS */
 446                 {errno = EINVAL; return -1;}
 447 #endif /* ndef _CS_XBS5_LPBIG_OFFBIG_CFLAGS */
 448         if (x == Mono_Posix_ConfstrName__CS_XBS5_LPBIG_OFFBIG_LDFLAGS)
 449 #ifdef _CS_XBS5_LPBIG_OFFBIG_LDFLAGS
 450                 {*r = _CS_XBS5_LPBIG_OFFBIG_LDFLAGS; return 0;}
 451 #else /* def _CS_XBS5_LPBIG_OFFBIG_LDFLAGS */
 452                 {errno = EINVAL; return -1;}
 453 #endif /* ndef _CS_XBS5_LPBIG_OFFBIG_LDFLAGS */
 454         if (x == Mono_Posix_ConfstrName__CS_XBS5_LPBIG_OFFBIG_LIBS)
 455 #ifdef _CS_XBS5_LPBIG_OFFBIG_LIBS
 456                 {*r = _CS_XBS5_LPBIG_OFFBIG_LIBS; return 0;}
 457 #else /* def _CS_XBS5_LPBIG_OFFBIG_LIBS */
 458                 {errno = EINVAL; return -1;}
 459 #endif /* ndef _CS_XBS5_LPBIG_OFFBIG_LIBS */
 460         if (x == Mono_Posix_ConfstrName__CS_XBS5_LPBIG_OFFBIG_LINTFLAGS)
 461 #ifdef _CS_XBS5_LPBIG_OFFBIG_LINTFLAGS
 462                 {*r = _CS_XBS5_LPBIG_OFFBIG_LINTFLAGS; return 0;}
 463 #else /* def _CS_XBS5_LPBIG_OFFBIG_LINTFLAGS */
 464                 {errno = EINVAL; return -1;}
 465 #endif /* ndef _CS_XBS5_LPBIG_OFFBIG_LINTFLAGS */
 466         if (x == 0)
 467                 return 0;
 468         errno = EINVAL; return -1;
 469 }
 470
 471 int Mono_Posix_ToConfstrName (int x, int *r)
 472 {
 473         *r = 0;
 474         if (x == 0)
 475                 return 0;
 476 #ifdef _CS_GNU_LIBC_VERSION
 477         if (x == _CS_GNU_LIBC_VERSION)
 478                 {*r = Mono_Posix_ConfstrName__CS_GNU_LIBC_VERSION; return 0;}
 479 #endif /* ndef _CS_GNU_LIBC_VERSION */
 480 #ifdef _CS_GNU_LIBPTHREAD_VERSION
 481         if (x == _CS_GNU_LIBPTHREAD_VERSION)
 482                 {*r = Mono_Posix_ConfstrName__CS_GNU_LIBPTHREAD_VERSION; return 0;}
 483 #endif /* ndef _CS_GNU_LIBPTHREAD_VERSION */
 484 #ifdef _CS_LFS64_CFLAGS
 485         if (x == _CS_LFS64_CFLAGS)
 486                 {*r = Mono_Posix_ConfstrName__CS_LFS64_CFLAGS; return 0;}
 487 #endif /* ndef _CS_LFS64_CFLAGS */
 488 #ifdef _CS_LFS64_LDFLAGS
 489         if (x == _CS_LFS64_LDFLAGS)
 490                 {*r = Mono_Posix_ConfstrName__CS_LFS64_LDFLAGS; return 0;}
 491 #endif /* ndef _CS_LFS64_LDFLAGS */
 492 #ifdef _CS_LFS64_LIBS
 493         if (x == _CS_LFS64_LIBS)
 494                 {*r = Mono_Posix_ConfstrName__CS_LFS64_LIBS; return 0;}
 495 #endif /* ndef _CS_LFS64_LIBS */
 496 #ifdef _CS_LFS64_LINTFLAGS
 497         if (x == _CS_LFS64_LINTFLAGS)
 498                 {*r = Mono_Posix_ConfstrName__CS_LFS64_LINTFLAGS; return 0;}
 499 #endif /* ndef _CS_LFS64_LINTFLAGS */
 500 #ifdef _CS_LFS_CFLAGS
 501         if (x == _CS_LFS_CFLAGS)
 502                 {*r = Mono_Posix_ConfstrName__CS_LFS_CFLAGS; return 0;}
 503 #endif /* ndef _CS_LFS_CFLAGS */
 504 #ifdef _CS_LFS_LDFLAGS
 505         if (x == _CS_LFS_LDFLAGS)
 506                 {*r = Mono_Posix_ConfstrName__CS_LFS_LDFLAGS; return 0;}
 507 #endif /* ndef _CS_LFS_LDFLAGS */
 508 #ifdef _CS_LFS_LIBS
 509         if (x == _CS_LFS_LIBS)
 510                 {*r = Mono_Posix_ConfstrName__CS_LFS_LIBS; return 0;}
 511 #endif /* ndef _CS_LFS_LIBS */
 512 #ifdef _CS_LFS_LINTFLAGS
 513         if (x == _CS_LFS_LINTFLAGS)
 514                 {*r = Mono_Posix_ConfstrName__CS_LFS_LINTFLAGS; return 0;}
 515 #endif /* ndef _CS_LFS_LINTFLAGS */
 516 #ifdef _CS_PATH
 517         if (x == _CS_PATH)
 518                 {*r = Mono_Posix_ConfstrName__CS_PATH; return 0;}
 519 #endif /* ndef _CS_PATH */
 520 #ifdef _CS_POSIX_V6_ILP32_OFF32_CFLAGS
 521         if (x == _CS_POSIX_V6_ILP32_OFF32_CFLAGS)
 522                 {*r = Mono_Posix_ConfstrName__CS_POSIX_V6_ILP32_OFF32_CFLAGS; return 0;}
 523 #endif /* ndef _CS_POSIX_V6_ILP32_OFF32_CFLAGS */
 524 #ifdef _CS_POSIX_V6_ILP32_OFF32_LDFLAGS
 525         if (x == _CS_POSIX_V6_ILP32_OFF32_LDFLAGS)
 526                 {*r = Mono_Posix_ConfstrName__CS_POSIX_V6_ILP32_OFF32_LDFLAGS; return 0;}
 527 #endif /* ndef _CS_POSIX_V6_ILP32_OFF32_LDFLAGS */
 528 #ifdef _CS_POSIX_V6_ILP32_OFF32_LIBS
 529         if (x == _CS_POSIX_V6_ILP32_OFF32_LIBS)
 530                 {*r = Mono_Posix_ConfstrName__CS_POSIX_V6_ILP32_OFF32_LIBS; return 0;}
 531 #endif /* ndef _CS_POSIX_V6_ILP32_OFF32_LIBS */
 532 #ifdef _CS_POSIX_V6_ILP32_OFF32_LINTFLAGS
 533         if (x == _CS_POSIX_V6_ILP32_OFF32_LINTFLAGS)
 534                 {*r = Mono_Posix_ConfstrName__CS_POSIX_V6_ILP32_OFF32_LINTFLAGS; return 0;}
 535 #endif /* ndef _CS_POSIX_V6_ILP32_OFF32_LINTFLAGS */
 536 #ifdef _CS_POSIX_V6_ILP32_OFFBIG_CFLAGS
 537         if (x == _CS_POSIX_V6_ILP32_OFFBIG_CFLAGS)
 538                 {*r = Mono_Posix_ConfstrName__CS_POSIX_V6_ILP32_OFFBIG_CFLAGS; return 0;}
 539 #endif /* ndef _CS_POSIX_V6_ILP32_OFFBIG_CFLAGS */
 540 #ifdef _CS_POSIX_V6_ILP32_OFFBIG_LDFLAGS
 541         if (x == _CS_POSIX_V6_ILP32_OFFBIG_LDFLAGS)
 542                 {*r = Mono_Posix_ConfstrName__CS_POSIX_V6_ILP32_OFFBIG_LDFLAGS; return 0;}
 543 #endif /* ndef _CS_POSIX_V6_ILP32_OFFBIG_LDFLAGS */
 544 #ifdef _CS_POSIX_V6_ILP32_OFFBIG_LIBS
 545         if (x == _CS_POSIX_V6_ILP32_OFFBIG_LIBS)
 546                 {*r = Mono_Posix_ConfstrName__CS_POSIX_V6_ILP32_OFFBIG_LIBS; return 0;}
 547 #endif /* ndef _CS_POSIX_V6_ILP32_OFFBIG_LIBS */
 548 #ifdef _CS_POSIX_V6_ILP32_OFFBIG_LINTFLAGS
 549         if (x == _CS_POSIX_V6_ILP32_OFFBIG_LINTFLAGS)
 550                 {*r = Mono_Posix_ConfstrName__CS_POSIX_V6_ILP32_OFFBIG_LINTFLAGS; return 0;}
 551 #endif /* ndef _CS_POSIX_V6_ILP32_OFFBIG_LINTFLAGS */
 552 #ifdef _CS_POSIX_V6_LP64_OFF64_CFLAGS
 553         if (x == _CS_POSIX_V6_LP64_OFF64_CFLAGS)
 554                 {*r = Mono_Posix_ConfstrName__CS_POSIX_V6_LP64_OFF64_CFLAGS; return 0;}
 555 #endif /* ndef _CS_POSIX_V6_LP64_OFF64_CFLAGS */
 556 #ifdef _CS_POSIX_V6_LP64_OFF64_LDFLAGS
 557         if (x == _CS_POSIX_V6_LP64_OFF64_LDFLAGS)
 558                 {*r = Mono_Posix_ConfstrName__CS_POSIX_V6_LP64_OFF64_LDFLAGS; return 0;}
 559 #endif /* ndef _CS_POSIX_V6_LP64_OFF64_LDFLAGS */
 560 #ifdef _CS_POSIX_V6_LP64_OFF64_LIBS
 561         if (x == _CS_POSIX_V6_LP64_OFF64_LIBS)
 562                 {*r = Mono_Posix_ConfstrName__CS_POSIX_V6_LP64_OFF64_LIBS; return 0;}
 563 #endif /* ndef _CS_POSIX_V6_LP64_OFF64_LIBS */
 564 #ifdef _CS_POSIX_V6_LP64_OFF64_LINTFLAGS
 565         if (x == _CS_POSIX_V6_LP64_OFF64_LINTFLAGS)
 566                 {*r = Mono_Posix_ConfstrName__CS_POSIX_V6_LP64_OFF64_LINTFLAGS; return 0;}
 567 #endif /* ndef _CS_POSIX_V6_LP64_OFF64_LINTFLAGS */
 568 #ifdef _CS_POSIX_V6_LPBIG_OFFBIG_CFLAGS
 569         if (x == _CS_POSIX_V6_LPBIG_OFFBIG_CFLAGS)
 570                 {*r = Mono_Posix_ConfstrName__CS_POSIX_V6_LPBIG_OFFBIG_CFLAGS; return 0;}
 571 #endif /* ndef _CS_POSIX_V6_LPBIG_OFFBIG_CFLAGS */
 572 #ifdef _CS_POSIX_V6_LPBIG_OFFBIG_LDFLAGS
 573         if (x == _CS_POSIX_V6_LPBIG_OFFBIG_LDFLAGS)
 574                 {*r = Mono_Posix_ConfstrName__CS_POSIX_V6_LPBIG_OFFBIG_LDFLAGS; return 0;}
 575 #endif /* ndef _CS_POSIX_V6_LPBIG_OFFBIG_LDFLAGS */
 576 #ifdef _CS_POSIX_V6_LPBIG_OFFBIG_LIBS
 577         if (x == _CS_POSIX_V6_LPBIG_OFFBIG_LIBS)
 578                 {*r = Mono_Posix_ConfstrName__CS_POSIX_V6_LPBIG_OFFBIG_LIBS; return 0;}
 579 #endif /* ndef _CS_POSIX_V6_LPBIG_OFFBIG_LIBS */
 580 #ifdef _CS_POSIX_V6_LPBIG_OFFBIG_LINTFLAGS
 581         if (x == _CS_POSIX_V6_LPBIG_OFFBIG_LINTFLAGS)
 582                 {*r = Mono_Posix_ConfstrName__CS_POSIX_V6_LPBIG_OFFBIG_LINTFLAGS; return 0;}
 583 #endif /* ndef _CS_POSIX_V6_LPBIG_OFFBIG_LINTFLAGS */
 584 #ifdef _CS_V6_WIDTH_RESTRICTED_ENVS
 585         if (x == _CS_V6_WIDTH_RESTRICTED_ENVS)
 586                 {*r = Mono_Posix_ConfstrName__CS_V6_WIDTH_RESTRICTED_ENVS; return 0;}
 587 #endif /* ndef _CS_V6_WIDTH_RESTRICTED_ENVS */
 588 #ifdef _CS_XBS5_ILP32_OFF32_CFLAGS
 589         if (x == _CS_XBS5_ILP32_OFF32_CFLAGS)
 590                 {*r = Mono_Posix_ConfstrName__CS_XBS5_ILP32_OFF32_CFLAGS; return 0;}
 591 #endif /* ndef _CS_XBS5_ILP32_OFF32_CFLAGS */
 592 #ifdef _CS_XBS5_ILP32_OFF32_LDFLAGS
 593         if (x == _CS_XBS5_ILP32_OFF32_LDFLAGS)
 594                 {*r = Mono_Posix_ConfstrName__CS_XBS5_ILP32_OFF32_LDFLAGS; return 0;}
 595 #endif /* ndef _CS_XBS5_ILP32_OFF32_LDFLAGS */
 596 #ifdef _CS_XBS5_ILP32_OFF32_LIBS
 597         if (x == _CS_XBS5_ILP32_OFF32_LIBS)
 598                 {*r = Mono_Posix_ConfstrName__CS_XBS5_ILP32_OFF32_LIBS; return 0;}
 599 #endif /* ndef _CS_XBS5_ILP32_OFF32_LIBS */
 600 #ifdef _CS_XBS5_ILP32_OFF32_LINTFLAGS
 601         if (x == _CS_XBS5_ILP32_OFF32_LINTFLAGS)
 602                 {*r = Mono_Posix_ConfstrName__CS_XBS5_ILP32_OFF32_LINTFLAGS; return 0;}
 603 #endif /* ndef _CS_XBS5_ILP32_OFF32_LINTFLAGS */
 604 #ifdef _CS_XBS5_ILP32_OFFBIG_CFLAGS
 605         if (x == _CS_XBS5_ILP32_OFFBIG_CFLAGS)
 606                 {*r = Mono_Posix_ConfstrName__CS_XBS5_ILP32_OFFBIG_CFLAGS; return 0;}
 607 #endif /* ndef _CS_XBS5_ILP32_OFFBIG_CFLAGS */
 608 #ifdef _CS_XBS5_ILP32_OFFBIG_LDFLAGS
 609         if (x == _CS_XBS5_ILP32_OFFBIG_LDFLAGS)
 610                 {*r = Mono_Posix_ConfstrName__CS_XBS5_ILP32_OFFBIG_LDFLAGS; return 0;}
 611 #endif /* ndef _CS_XBS5_ILP32_OFFBIG_LDFLAGS */
 612 #ifdef _CS_XBS5_ILP32_OFFBIG_LIBS
 613         if (x == _CS_XBS5_ILP32_OFFBIG_LIBS)
 614                 {*r = Mono_Posix_ConfstrName__CS_XBS5_ILP32_OFFBIG_LIBS; return 0;}
 615 #endif /* ndef _CS_XBS5_ILP32_OFFBIG_LIBS */
 616 #ifdef _CS_XBS5_ILP32_OFFBIG_LINTFLAGS
 617         if (x == _CS_XBS5_ILP32_OFFBIG_LINTFLAGS)
 618                 {*r = Mono_Posix_ConfstrName__CS_XBS5_ILP32_OFFBIG_LINTFLAGS; return 0;}
 619 #endif /* ndef _CS_XBS5_ILP32_OFFBIG_LINTFLAGS */
 620 #ifdef _CS_XBS5_LP64_OFF64_CFLAGS
 621         if (x == _CS_XBS5_LP64_OFF64_CFLAGS)
 622                 {*r = Mono_Posix_ConfstrName__CS_XBS5_LP64_OFF64_CFLAGS; return 0;}
 623 #endif /* ndef _CS_XBS5_LP64_OFF64_CFLAGS */
 624 #ifdef _CS_XBS5_LP64_OFF64_LDFLAGS
 625         if (x == _CS_XBS5_LP64_OFF64_LDFLAGS)
 626                 {*r = Mono_Posix_ConfstrName__CS_XBS5_LP64_OFF64_LDFLAGS; return 0;}
 627 #endif /* ndef _CS_XBS5_LP64_OFF64_LDFLAGS */
 628 #ifdef _CS_XBS5_LP64_OFF64_LIBS
 629         if (x == _CS_XBS5_LP64_OFF64_LIBS)
 630                 {*r = Mono_Posix_ConfstrName__CS_XBS5_LP64_OFF64_LIBS; return 0;}
 631 #endif /* ndef _CS_XBS5_LP64_OFF64_LIBS */
 632 #ifdef _CS_XBS5_LP64_OFF64_LINTFLAGS
 633         if (x == _CS_XBS5_LP64_OFF64_LINTFLAGS)
 634                 {*r = Mono_Posix_ConfstrName__CS_XBS5_LP64_OFF64_LINTFLAGS; return 0;}
 635 #endif /* ndef _CS_XBS5_LP64_OFF64_LINTFLAGS */
 636 #ifdef _CS_XBS5_LPBIG_OFFBIG_CFLAGS
 637         if (x == _CS_XBS5_LPBIG_OFFBIG_CFLAGS)
 638                 {*r = Mono_Posix_ConfstrName__CS_XBS5_LPBIG_OFFBIG_CFLAGS; return 0;}
 639 #endif /* ndef _CS_XBS5_LPBIG_OFFBIG_CFLAGS */
 640 #ifdef _CS_XBS5_LPBIG_OFFBIG_LDFLAGS
 641         if (x == _CS_XBS5_LPBIG_OFFBIG_LDFLAGS)
 642                 {*r = Mono_Posix_ConfstrName__CS_XBS5_LPBIG_OFFBIG_LDFLAGS; return 0;}
 643 #endif /* ndef _CS_XBS5_LPBIG_OFFBIG_LDFLAGS */
 644 #ifdef _CS_XBS5_LPBIG_OFFBIG_LIBS
 645         if (x == _CS_XBS5_LPBIG_OFFBIG_LIBS)
 646                 {*r = Mono_Posix_ConfstrName__CS_XBS5_LPBIG_OFFBIG_LIBS; return 0;}
 647 #endif /* ndef _CS_XBS5_LPBIG_OFFBIG_LIBS */
 648 #ifdef _CS_XBS5_LPBIG_OFFBIG_LINTFLAGS
 649         if (x == _CS_XBS5_LPBIG_OFFBIG_LINTFLAGS)
 650                 {*r = Mono_Posix_ConfstrName__CS_XBS5_LPBIG_OFFBIG_LINTFLAGS; return 0;}
 651 #endif /* ndef _CS_XBS5_LPBIG_OFFBIG_LINTFLAGS */
 652         errno = EINVAL; return -1;
 653 }
 654
 655 int Mono_Posix_FromDirectoryNotifyFlags (int x, int *r)
 656 {
 657         *r = 0;
 658         if ((x & Mono_Posix_DirectoryNotifyFlags_DN_ACCESS) == Mono_Posix_DirectoryNotifyFlags_DN_ACCESS)
 659 #ifdef DN_ACCESS
 660                 *r |= DN_ACCESS;
 661 #else /* def DN_ACCESS */
 662                 {errno = EINVAL; return -1;}
 663 #endif /* ndef DN_ACCESS */
 664         if ((x & Mono_Posix_DirectoryNotifyFlags_DN_ATTRIB) == Mono_Posix_DirectoryNotifyFlags_DN_ATTRIB)
 665 #ifdef DN_ATTRIB
 666                 *r |= DN_ATTRIB;
 667 #else /* def DN_ATTRIB */
 668                 {errno = EINVAL; return -1;}
 669 #endif /* ndef DN_ATTRIB */
 670         if ((x & Mono_Posix_DirectoryNotifyFlags_DN_CREATE) == Mono_Posix_DirectoryNotifyFlags_DN_CREATE)
 671 #ifdef DN_CREATE
 672                 *r |= DN_CREATE;
 673 #else /* def DN_CREATE */
 674                 {errno = EINVAL; return -1;}
 675 #endif /* ndef DN_CREATE */
 676         if ((x & Mono_Posix_DirectoryNotifyFlags_DN_DELETE) == Mono_Posix_DirectoryNotifyFlags_DN_DELETE)
 677 #ifdef DN_DELETE
 678                 *r |= DN_DELETE;
 679 #else /* def DN_DELETE */
 680                 {errno = EINVAL; return -1;}
 681 #endif /* ndef DN_DELETE */
 682         if ((x & Mono_Posix_DirectoryNotifyFlags_DN_MODIFY) == Mono_Posix_DirectoryNotifyFlags_DN_MODIFY)
 683 #ifdef DN_MODIFY
 684                 *r |= DN_MODIFY;
 685 #else /* def DN_MODIFY */
 686                 {errno = EINVAL; return -1;}
 687 #endif /* ndef DN_MODIFY */
 688         if ((x & Mono_Posix_DirectoryNotifyFlags_DN_MULTISHOT) == Mono_Posix_DirectoryNotifyFlags_DN_MULTISHOT)
 689 #ifdef DN_MULTISHOT
 690                 *r |= DN_MULTISHOT;
 691 #else /* def DN_MULTISHOT */
 692                 {errno = EINVAL; return -1;}
 693 #endif /* ndef DN_MULTISHOT */
 694         if ((x & Mono_Posix_DirectoryNotifyFlags_DN_RENAME) == Mono_Posix_DirectoryNotifyFlags_DN_RENAME)
 695 #ifdef DN_RENAME
 696                 *r |= DN_RENAME;
 697 #else /* def DN_RENAME */
 698                 {errno = EINVAL; return -1;}
 699 #endif /* ndef DN_RENAME */
 700         if (x == 0)
 701                 return 0;
 702         return 0;
 703 }
 704
 705 int Mono_Posix_ToDirectoryNotifyFlags (int x, int *r)
 706 {
 707         *r = 0;
 708         if (x == 0)
 709                 return 0;
 710 #ifdef DN_ACCESS
 711         if ((x & DN_ACCESS) == DN_ACCESS)
 712                 *r |= Mono_Posix_DirectoryNotifyFlags_DN_ACCESS;
 713 #endif /* ndef DN_ACCESS */
 714 #ifdef DN_ATTRIB
 715         if ((x & DN_ATTRIB) == DN_ATTRIB)
 716                 *r |= Mono_Posix_DirectoryNotifyFlags_DN_ATTRIB;
 717 #endif /* ndef DN_ATTRIB */
 718 #ifdef DN_CREATE
 719         if ((x & DN_CREATE) == DN_CREATE)
 720                 *r |= Mono_Posix_DirectoryNotifyFlags_DN_CREATE;
 721 #endif /* ndef DN_CREATE */
 722 #ifdef DN_DELETE
 723         if ((x & DN_DELETE) == DN_DELETE)
 724                 *r |= Mono_Posix_DirectoryNotifyFlags_DN_DELETE;
 725 #endif /* ndef DN_DELETE */
 726 #ifdef DN_MODIFY
 727         if ((x & DN_MODIFY) == DN_MODIFY)
 728                 *r |= Mono_Posix_DirectoryNotifyFlags_DN_MODIFY;
 729 #endif /* ndef DN_MODIFY */
 730 #ifdef DN_MULTISHOT
 731         if ((x & DN_MULTISHOT) == DN_MULTISHOT)
 732                 *r |= Mono_Posix_DirectoryNotifyFlags_DN_MULTISHOT;
 733 #endif /* ndef DN_MULTISHOT */
 734 #ifdef DN_RENAME
 735         if ((x & DN_RENAME) == DN_RENAME)
 736                 *r |= Mono_Posix_DirectoryNotifyFlags_DN_RENAME;
 737 #endif /* ndef DN_RENAME */
 738         return 0;
 739 }
 740
 741 int Mono_Posix_FromErrno (int x, int *r)
 742 {
 743         *r = 0;
 744         if (x == Mono_Posix_Errno_E2BIG)
 745 #ifdef E2BIG
 746                 {*r = E2BIG; return 0;}
 747 #else /* def E2BIG */
 748                 {errno = EINVAL; return -1;}
 749 #endif /* ndef E2BIG */
 750         if (x == Mono_Posix_Errno_EACCES)
 751 #ifdef EACCES
 752                 {*r = EACCES; return 0;}
 753 #else /* def EACCES */
 754                 {errno = EINVAL; return -1;}
 755 #endif /* ndef EACCES */
 756         if (x == Mono_Posix_Errno_EADDRINUSE)
 757 #ifdef EADDRINUSE
 758                 {*r = EADDRINUSE; return 0;}
 759 #else /* def EADDRINUSE */
 760                 {errno = EINVAL; return -1;}
 761 #endif /* ndef EADDRINUSE */
 762         if (x == Mono_Posix_Errno_EADDRNOTAVAIL)
 763 #ifdef EADDRNOTAVAIL
 764                 {*r = EADDRNOTAVAIL; return 0;}
 765 #else /* def EADDRNOTAVAIL */
 766                 {errno = EINVAL; return -1;}
 767 #endif /* ndef EADDRNOTAVAIL */
 768         if (x == Mono_Posix_Errno_EADV)
 769 #ifdef EADV
 770                 {*r = EADV; return 0;}
 771 #else /* def EADV */
 772                 {errno = EINVAL; return -1;}
 773 #endif /* ndef EADV */
 774         if (x == Mono_Posix_Errno_EAFNOSUPPORT)
 775 #ifdef EAFNOSUPPORT
 776                 {*r = EAFNOSUPPORT; return 0;}
 777 #else /* def EAFNOSUPPORT */
 778                 {errno = EINVAL; return -1;}
 779 #endif /* ndef EAFNOSUPPORT */
 780         if (x == Mono_Posix_Errno_EAGAIN)
 781 #ifdef EAGAIN
 782                 {*r = EAGAIN; return 0;}
 783 #else /* def EAGAIN */
 784                 {errno = EINVAL; return -1;}
 785 #endif /* ndef EAGAIN */
 786         if (x == Mono_Posix_Errno_EALREADY)
 787 #ifdef EALREADY
 788                 {*r = EALREADY; return 0;}
 789 #else /* def EALREADY */
 790                 {errno = EINVAL; return -1;}
 791 #endif /* ndef EALREADY */
 792         if (x == Mono_Posix_Errno_EBADE)
 793 #ifdef EBADE
 794                 {*r = EBADE; return 0;}
 795 #else /* def EBADE */
 796                 {errno = EINVAL; return -1;}
 797 #endif /* ndef EBADE */
 798         if (x == Mono_Posix_Errno_EBADF)
 799 #ifdef EBADF
 800                 {*r = EBADF; return 0;}
 801 #else /* def EBADF */
 802                 {errno = EINVAL; return -1;}
 803 #endif /* ndef EBADF */
 804         if (x == Mono_Posix_Errno_EBADFD)
 805 #ifdef EBADFD
 806                 {*r = EBADFD; return 0;}
 807 #else /* def EBADFD */
 808                 {errno = EINVAL; return -1;}
 809 #endif /* ndef EBADFD */
 810         if (x == Mono_Posix_Errno_EBADMSG)
 811 #ifdef EBADMSG
 812                 {*r = EBADMSG; return 0;}
 813 #else /* def EBADMSG */
 814                 {errno = EINVAL; return -1;}
 815 #endif /* ndef EBADMSG */
 816         if (x == Mono_Posix_Errno_EBADR)
 817 #ifdef EBADR
 818                 {*r = EBADR; return 0;}
 819 #else /* def EBADR */
 820                 {errno = EINVAL; return -1;}
 821 #endif /* ndef EBADR */
 822         if (x == Mono_Posix_Errno_EBADRQC)
 823 #ifdef EBADRQC
 824                 {*r = EBADRQC; return 0;}
 825 #else /* def EBADRQC */
 826                 {errno = EINVAL; return -1;}
 827 #endif /* ndef EBADRQC */
 828         if (x == Mono_Posix_Errno_EBADSLT)
 829 #ifdef EBADSLT
 830                 {*r = EBADSLT; return 0;}
 831 #else /* def EBADSLT */
 832                 {errno = EINVAL; return -1;}
 833 #endif /* ndef EBADSLT */
 834         if (x == Mono_Posix_Errno_EBFONT)
 835 #ifdef EBFONT
 836                 {*r = EBFONT; return 0;}
 837 #else /* def EBFONT */
 838                 {errno = EINVAL; return -1;}
 839 #endif /* ndef EBFONT */
 840         if (x == Mono_Posix_Errno_EBUSY)
 841 #ifdef EBUSY
 842                 {*r = EBUSY; return 0;}
 843 #else /* def EBUSY */
 844                 {errno = EINVAL; return -1;}
 845 #endif /* ndef EBUSY */
 846         if (x == Mono_Posix_Errno_ECHILD)
 847 #ifdef ECHILD
 848                 {*r = ECHILD; return 0;}
 849 #else /* def ECHILD */
 850                 {errno = EINVAL; return -1;}
 851 #endif /* ndef ECHILD */
 852         if (x == Mono_Posix_Errno_ECHRNG)
 853 #ifdef ECHRNG
 854                 {*r = ECHRNG; return 0;}
 855 #else /* def ECHRNG */
 856                 {errno = EINVAL; return -1;}
 857 #endif /* ndef ECHRNG */
 858         if (x == Mono_Posix_Errno_ECOMM)
 859 #ifdef ECOMM
 860                 {*r = ECOMM; return 0;}
 861 #else /* def ECOMM */
 862                 {errno = EINVAL; return -1;}
 863 #endif /* ndef ECOMM */
 864         if (x == Mono_Posix_Errno_ECONNABORTED)
 865 #ifdef ECONNABORTED
 866                 {*r = ECONNABORTED; return 0;}
 867 #else /* def ECONNABORTED */
 868                 {errno = EINVAL; return -1;}
 869 #endif /* ndef ECONNABORTED */
 870         if (x == Mono_Posix_Errno_ECONNREFUSED)
 871 #ifdef ECONNREFUSED
 872                 {*r = ECONNREFUSED; return 0;}
 873 #else /* def ECONNREFUSED */
 874                 {errno = EINVAL; return -1;}
 875 #endif /* ndef ECONNREFUSED */
 876         if (x == Mono_Posix_Errno_ECONNRESET)
 877 #ifdef ECONNRESET
 878                 {*r = ECONNRESET; return 0;}
 879 #else /* def ECONNRESET */
 880                 {errno = EINVAL; return -1;}
 881 #endif /* ndef ECONNRESET */
 882         if (x == Mono_Posix_Errno_EDEADLK)
 883 #ifdef EDEADLK
 884                 {*r = EDEADLK; return 0;}
 885 #else /* def EDEADLK */
 886                 {errno = EINVAL; return -1;}
 887 #endif /* ndef EDEADLK */
 888         if (x == Mono_Posix_Errno_EDEADLOCK)
 889 #ifdef EDEADLOCK
 890                 {*r = EDEADLOCK; return 0;}
 891 #else /* def EDEADLOCK */
 892                 {errno = EINVAL; return -1;}
 893 #endif /* ndef EDEADLOCK */
 894         if (x == Mono_Posix_Errno_EDESTADDRREQ)
 895 #ifdef EDESTADDRREQ
 896                 {*r = EDESTADDRREQ; return 0;}
 897 #else /* def EDESTADDRREQ */
 898                 {errno = EINVAL; return -1;}
 899 #endif /* ndef EDESTADDRREQ */
 900         if (x == Mono_Posix_Errno_EDOM)
 901 #ifdef EDOM
 902                 {*r = EDOM; return 0;}
 903 #else /* def EDOM */
 904                 {errno = EINVAL; return -1;}
 905 #endif /* ndef EDOM */
 906         if (x == Mono_Posix_Errno_EDOTDOT)
 907 #ifdef EDOTDOT
 908                 {*r = EDOTDOT; return 0;}
 909 #else /* def EDOTDOT */
 910                 {errno = EINVAL; return -1;}
 911 #endif /* ndef EDOTDOT */
 912         if (x == Mono_Posix_Errno_EDQUOT)
 913 #ifdef EDQUOT
 914                 {*r = EDQUOT; return 0;}
 915 #else /* def EDQUOT */
 916                 {errno = EINVAL; return -1;}
 917 #endif /* ndef EDQUOT */
 918         if (x == Mono_Posix_Errno_EEXIST)
 919 #ifdef EEXIST
 920                 {*r = EEXIST; return 0;}
 921 #else /* def EEXIST */
 922                 {errno = EINVAL; return -1;}
 923 #endif /* ndef EEXIST */
 924         if (x == Mono_Posix_Errno_EFAULT)
 925 #ifdef EFAULT
 926                 {*r = EFAULT; return 0;}
 927 #else /* def EFAULT */
 928                 {errno = EINVAL; return -1;}
 929 #endif /* ndef EFAULT */
 930         if (x == Mono_Posix_Errno_EFBIG)
 931 #ifdef EFBIG
 932                 {*r = EFBIG; return 0;}
 933 #else /* def EFBIG */
 934                 {errno = EINVAL; return -1;}
 935 #endif /* ndef EFBIG */
 936         if (x == Mono_Posix_Errno_EHOSTDOWN)
 937 #ifdef EHOSTDOWN
 938                 {*r = EHOSTDOWN; return 0;}
 939 #else /* def EHOSTDOWN */
 940                 {errno = EINVAL; return -1;}
 941 #endif /* ndef EHOSTDOWN */
 942         if (x == Mono_Posix_Errno_EHOSTUNREACH)
 943 #ifdef EHOSTUNREACH
 944                 {*r = EHOSTUNREACH; return 0;}
 945 #else /* def EHOSTUNREACH */
 946                 {errno = EINVAL; return -1;}
 947 #endif /* ndef EHOSTUNREACH */
 948         if (x == Mono_Posix_Errno_EIDRM)
 949 #ifdef EIDRM
 950                 {*r = EIDRM; return 0;}
 951 #else /* def EIDRM */
 952                 {errno = EINVAL; return -1;}
 953 #endif /* ndef EIDRM */
 954         if (x == Mono_Posix_Errno_EILSEQ)
 955 #ifdef EILSEQ
 956                 {*r = EILSEQ; return 0;}
 957 #else /* def EILSEQ */
 958                 {errno = EINVAL; return -1;}
 959 #endif /* ndef EILSEQ */
 960         if (x == Mono_Posix_Errno_EINPROGRESS)
 961 #ifdef EINPROGRESS
 962                 {*r = EINPROGRESS; return 0;}
 963 #else /* def EINPROGRESS */
 964                 {errno = EINVAL; return -1;}
 965 #endif /* ndef EINPROGRESS */
 966         if (x == Mono_Posix_Errno_EINTR)
 967 #ifdef EINTR
 968                 {*r = EINTR; return 0;}
 969 #else /* def EINTR */
 970                 {errno = EINVAL; return -1;}
 971 #endif /* ndef EINTR */
 972         if (x == Mono_Posix_Errno_EINVAL)
 973 #ifdef EINVAL
 974                 {*r = EINVAL; return 0;}
 975 #else /* def EINVAL */
 976                 {errno = EINVAL; return -1;}
 977 #endif /* ndef EINVAL */
 978         if (x == Mono_Posix_Errno_EIO)
 979 #ifdef EIO
 980                 {*r = EIO; return 0;}
 981 #else /* def EIO */
 982                 {errno = EINVAL; return -1;}
 983 #endif /* ndef EIO */
 984         if (x == Mono_Posix_Errno_EISCONN)
 985 #ifdef EISCONN
 986                 {*r = EISCONN; return 0;}
 987 #else /* def EISCONN */
 988                 {errno = EINVAL; return -1;}
 989 #endif /* ndef EISCONN */
 990         if (x == Mono_Posix_Errno_EISDIR)
 991 #ifdef EISDIR
 992                 {*r = EISDIR; return 0;}
 993 #else /* def EISDIR */
 994                 {errno = EINVAL; return -1;}
 995 #endif /* ndef EISDIR */
 996         if (x == Mono_Posix_Errno_EISNAM)
 997 #ifdef EISNAM
 998                 {*r = EISNAM; return 0;}
 999 #else /* def EISNAM */
1000                 {errno = EINVAL; return -1;}
1001 #endif /* ndef EISNAM */
1002         if (x == Mono_Posix_Errno_EL2HLT)
1003 #ifdef EL2HLT
1004                 {*r = EL2HLT; return 0;}
1005 #else /* def EL2HLT */
1006                 {errno = EINVAL; return -1;}
1007 #endif /* ndef EL2HLT */
1008         if (x == Mono_Posix_Errno_EL2NSYNC)
1009 #ifdef EL2NSYNC
1010                 {*r = EL2NSYNC; return 0;}
1011 #else /* def EL2NSYNC */
1012                 {errno = EINVAL; return -1;}
1013 #endif /* ndef EL2NSYNC */
1014         if (x == Mono_Posix_Errno_EL3HLT)
1015 #ifdef EL3HLT
1016                 {*r = EL3HLT; return 0;}
1017 #else /* def EL3HLT */
1018                 {errno = EINVAL; return -1;}
1019 #endif /* ndef EL3HLT */
1020         if (x == Mono_Posix_Errno_EL3RST)
1021 #ifdef EL3RST
1022                 {*r = EL3RST; return 0;}
1023 #else /* def EL3RST */
1024                 {errno = EINVAL; return -1;}
1025 #endif /* ndef EL3RST */
1026         if (x == Mono_Posix_Errno_ELIBACC)
1027 #ifdef ELIBACC
1028                 {*r = ELIBACC; return 0;}
1029 #else /* def ELIBACC */
1030                 {errno = EINVAL; return -1;}
1031 #endif /* ndef ELIBACC */
1032         if (x == Mono_Posix_Errno_ELIBBAD)
1033 #ifdef ELIBBAD
1034                 {*r = ELIBBAD; return 0;}
1035 #else /* def ELIBBAD */
1036                 {errno = EINVAL; return -1;}
1037 #endif /* ndef ELIBBAD */
1038         if (x == Mono_Posix_Errno_ELIBEXEC)
1039 #ifdef ELIBEXEC
1040                 {*r = ELIBEXEC; return 0;}
1041 #else /* def ELIBEXEC */
1042                 {errno = EINVAL; return -1;}
1043 #endif /* ndef ELIBEXEC */
1044         if (x == Mono_Posix_Errno_ELIBMAX)
1045 #ifdef ELIBMAX
1046                 {*r = ELIBMAX; return 0;}
1047 #else /* def ELIBMAX */
1048                 {errno = EINVAL; return -1;}
1049 #endif /* ndef ELIBMAX */
1050         if (x == Mono_Posix_Errno_ELIBSCN)
1051 #ifdef ELIBSCN
1052                 {*r = ELIBSCN; return 0;}
1053 #else /* def ELIBSCN */
1054                 {errno = EINVAL; return -1;}
1055 #endif /* ndef ELIBSCN */
1056         if (x == Mono_Posix_Errno_ELNRNG)
1057 #ifdef ELNRNG
1058                 {*r = ELNRNG; return 0;}
1059 #else /* def ELNRNG */
1060                 {errno = EINVAL; return -1;}
1061 #endif /* ndef ELNRNG */
1062         if (x == Mono_Posix_Errno_ELOOP)
1063 #ifdef ELOOP
1064                 {*r = ELOOP; return 0;}
1065 #else /* def ELOOP */
1066                 {errno = EINVAL; return -1;}
1067 #endif /* ndef ELOOP */
1068         if (x == Mono_Posix_Errno_EMEDIUMTYPE)
1069 #ifdef EMEDIUMTYPE
1070                 {*r = EMEDIUMTYPE; return 0;}
1071 #else /* def EMEDIUMTYPE */
1072                 {errno = EINVAL; return -1;}
1073 #endif /* ndef EMEDIUMTYPE */
1074         if (x == Mono_Posix_Errno_EMFILE)
1075 #ifdef EMFILE
1076                 {*r = EMFILE; return 0;}
1077 #else /* def EMFILE */
1078                 {errno = EINVAL; return -1;}
1079 #endif /* ndef EMFILE */
1080         if (x == Mono_Posix_Errno_EMLINK)
1081 #ifdef EMLINK
1082                 {*r = EMLINK; return 0;}
1083 #else /* def EMLINK */
1084                 {errno = EINVAL; return -1;}
1085 #endif /* ndef EMLINK */
1086         if (x == Mono_Posix_Errno_EMSGSIZE)
1087 #ifdef EMSGSIZE
1088                 {*r = EMSGSIZE; return 0;}
1089 #else /* def EMSGSIZE */
1090                 {errno = EINVAL; return -1;}
1091 #endif /* ndef EMSGSIZE */
1092         if (x == Mono_Posix_Errno_EMULTIHOP)
1093 #ifdef EMULTIHOP
1094                 {*r = EMULTIHOP; return 0;}
1095 #else /* def EMULTIHOP */
1096                 {errno = EINVAL; return -1;}
1097 #endif /* ndef EMULTIHOP */
1098         if (x == Mono_Posix_Errno_ENAMETOOLONG)
1099 #ifdef ENAMETOOLONG
1100                 {*r = ENAMETOOLONG; return 0;}
1101 #else /* def ENAMETOOLONG */
1102                 {errno = EINVAL; return -1;}
1103 #endif /* ndef ENAMETOOLONG */
1104         if (x == Mono_Posix_Errno_ENAVAIL)
1105 #ifdef ENAVAIL
1106                 {*r = ENAVAIL; return 0;}
1107 #else /* def ENAVAIL */
1108                 {errno = EINVAL; return -1;}
1109 #endif /* ndef ENAVAIL */
1110         if (x == Mono_Posix_Errno_ENETDOWN)
1111 #ifdef ENETDOWN
1112                 {*r = ENETDOWN; return 0;}
1113 #else /* def ENETDOWN */
1114                 {errno = EINVAL; return -1;}
1115 #endif /* ndef ENETDOWN */
1116         if (x == Mono_Posix_Errno_ENETRESET)
1117 #ifdef ENETRESET
1118                 {*r = ENETRESET; return 0;}
1119 #else /* def ENETRESET */
1120                 {errno = EINVAL; return -1;}
1121 #endif /* ndef ENETRESET */
1122         if (x == Mono_Posix_Errno_ENETUNREACH)
1123 #ifdef ENETUNREACH
1124                 {*r = ENETUNREACH; return 0;}
1125 #else /* def ENETUNREACH */
1126                 {errno = EINVAL; return -1;}
1127 #endif /* ndef ENETUNREACH */
1128         if (x == Mono_Posix_Errno_ENFILE)
1129 #ifdef ENFILE
1130                 {*r = ENFILE; return 0;}
1131 #else /* def ENFILE */
1132                 {errno = EINVAL; return -1;}
1133 #endif /* ndef ENFILE */
1134         if (x == Mono_Posix_Errno_ENOANO)
1135 #ifdef ENOANO
1136                 {*r = ENOANO; return 0;}
1137 #else /* def ENOANO */
1138                 {errno = EINVAL; return -1;}
1139 #endif /* ndef ENOANO */
1140         if (x == Mono_Posix_Errno_ENOBUFS)
1141 #ifdef ENOBUFS
1142                 {*r = ENOBUFS; return 0;}
1143 #else /* def ENOBUFS */
1144                 {errno = EINVAL; return -1;}
1145 #endif /* ndef ENOBUFS */
1146         if (x == Mono_Posix_Errno_ENOCSI)
1147 #ifdef ENOCSI
1148                 {*r = ENOCSI; return 0;}
1149 #else /* def ENOCSI */
1150                 {errno = EINVAL; return -1;}
1151 #endif /* ndef ENOCSI */
1152         if (x == Mono_Posix_Errno_ENODATA)
1153 #ifdef ENODATA
1154                 {*r = ENODATA; return 0;}
1155 #else /* def ENODATA */
1156                 {errno = EINVAL; return -1;}
1157 #endif /* ndef ENODATA */
1158         if (x == Mono_Posix_Errno_ENODEV)
1159 #ifdef ENODEV
1160                 {*r = ENODEV; return 0;}
1161 #else /* def ENODEV */
1162                 {errno = EINVAL; return -1;}
1163 #endif /* ndef ENODEV */
1164         if (x == Mono_Posix_Errno_ENOENT)
1165 #ifdef ENOENT
1166                 {*r = ENOENT; return 0;}
1167 #else /* def ENOENT */
1168                 {errno = EINVAL; return -1;}
1169 #endif /* ndef ENOENT */
1170         if (x == Mono_Posix_Errno_ENOEXEC)
1171 #ifdef ENOEXEC
1172                 {*r = ENOEXEC; return 0;}
1173 #else /* def ENOEXEC */
1174                 {errno = EINVAL; return -1;}
1175 #endif /* ndef ENOEXEC */
1176         if (x == Mono_Posix_Errno_ENOLCK)
1177 #ifdef ENOLCK
1178                 {*r = ENOLCK; return 0;}
1179 #else /* def ENOLCK */
1180                 {errno = EINVAL; return -1;}
1181 #endif /* ndef ENOLCK */
1182         if (x == Mono_Posix_Errno_ENOLINK)
1183 #ifdef ENOLINK
1184                 {*r = ENOLINK; return 0;}
1185 #else /* def ENOLINK */
1186                 {errno = EINVAL; return -1;}
1187 #endif /* ndef ENOLINK */
1188         if (x == Mono_Posix_Errno_ENOMEDIUM)
1189 #ifdef ENOMEDIUM
1190                 {*r = ENOMEDIUM; return 0;}
1191 #else /* def ENOMEDIUM */
1192                 {errno = EINVAL; return -1;}
1193 #endif /* ndef ENOMEDIUM */
1194         if (x == Mono_Posix_Errno_ENOMEM)
1195 #ifdef ENOMEM
1196                 {*r = ENOMEM; return 0;}
1197 #else /* def ENOMEM */
1198                 {errno = EINVAL; return -1;}
1199 #endif /* ndef ENOMEM */
1200         if (x == Mono_Posix_Errno_ENOMSG)
1201 #ifdef ENOMSG
1202                 {*r = ENOMSG; return 0;}
1203 #else /* def ENOMSG */
1204                 {errno = EINVAL; return -1;}
1205 #endif /* ndef ENOMSG */
1206         if (x == Mono_Posix_Errno_ENONET)
1207 #ifdef ENONET
1208                 {*r = ENONET; return 0;}
1209 #else /* def ENONET */
1210                 {errno = EINVAL; return -1;}
1211 #endif /* ndef ENONET */
1212         if (x == Mono_Posix_Errno_ENOPKG)
1213 #ifdef ENOPKG
1214                 {*r = ENOPKG; return 0;}
1215 #else /* def ENOPKG */
1216                 {errno = EINVAL; return -1;}
1217 #endif /* ndef ENOPKG */
1218         if (x == Mono_Posix_Errno_ENOPROTOOPT)
1219 #ifdef ENOPROTOOPT
1220                 {*r = ENOPROTOOPT; return 0;}
1221 #else /* def ENOPROTOOPT */
1222                 {errno = EINVAL; return -1;}
1223 #endif /* ndef ENOPROTOOPT */
1224         if (x == Mono_Posix_Errno_ENOSPC)
1225 #ifdef ENOSPC
1226                 {*r = ENOSPC; return 0;}
1227 #else /* def ENOSPC */
1228                 {errno = EINVAL; return -1;}
1229 #endif /* ndef ENOSPC */
1230         if (x == Mono_Posix_Errno_ENOSR)
1231 #ifdef ENOSR
1232                 {*r = ENOSR; return 0;}
1233 #else /* def ENOSR */
1234                 {errno = EINVAL; return -1;}
1235 #endif /* ndef ENOSR */
1236         if (x == Mono_Posix_Errno_ENOSTR)
1237 #ifdef ENOSTR
1238                 {*r = ENOSTR; return 0;}
1239 #else /* def ENOSTR */
1240                 {errno = EINVAL; return -1;}
1241 #endif /* ndef ENOSTR */
1242         if (x == Mono_Posix_Errno_ENOSYS)
1243 #ifdef ENOSYS
1244                 {*r = ENOSYS; return 0;}
1245 #else /* def ENOSYS */
1246                 {errno = EINVAL; return -1;}
1247 #endif /* ndef ENOSYS */
1248         if (x == Mono_Posix_Errno_ENOTBLK)
1249 #ifdef ENOTBLK
1250                 {*r = ENOTBLK; return 0;}
1251 #else /* def ENOTBLK */
1252                 {errno = EINVAL; return -1;}
1253 #endif /* ndef ENOTBLK */
1254         if (x == Mono_Posix_Errno_ENOTCONN)
1255 #ifdef ENOTCONN
1256                 {*r = ENOTCONN; return 0;}
1257 #else /* def ENOTCONN */
1258                 {errno = EINVAL; return -1;}
1259 #endif /* ndef ENOTCONN */
1260         if (x == Mono_Posix_Errno_ENOTDIR)
1261 #ifdef ENOTDIR
1262                 {*r = ENOTDIR; return 0;}
1263 #else /* def ENOTDIR */
1264                 {errno = EINVAL; return -1;}
1265 #endif /* ndef ENOTDIR */
1266         if (x == Mono_Posix_Errno_ENOTEMPTY)
1267 #ifdef ENOTEMPTY
1268                 {*r = ENOTEMPTY; return 0;}
1269 #else /* def ENOTEMPTY */
1270                 {errno = EINVAL; return -1;}
1271 #endif /* ndef ENOTEMPTY */
1272         if (x == Mono_Posix_Errno_ENOTNAM)
1273 #ifdef ENOTNAM
1274                 {*r = ENOTNAM; return 0;}
1275 #else /* def ENOTNAM */
1276                 {errno = EINVAL; return -1;}
1277 #endif /* ndef ENOTNAM */
1278         if (x == Mono_Posix_Errno_ENOTSOCK)
1279 #ifdef ENOTSOCK
1280                 {*r = ENOTSOCK; return 0;}
1281 #else /* def ENOTSOCK */
1282                 {errno = EINVAL; return -1;}
1283 #endif /* ndef ENOTSOCK */
1284         if (x == Mono_Posix_Errno_ENOTTY)
1285 #ifdef ENOTTY
1286                 {*r = ENOTTY; return 0;}
1287 #else /* def ENOTTY */
1288                 {errno = EINVAL; return -1;}
1289 #endif /* ndef ENOTTY */
1290         if (x == Mono_Posix_Errno_ENOTUNIQ)
1291 #ifdef ENOTUNIQ
1292                 {*r = ENOTUNIQ; return 0;}
1293 #else /* def ENOTUNIQ */
1294                 {errno = EINVAL; return -1;}
1295 #endif /* ndef ENOTUNIQ */
1296         if (x == Mono_Posix_Errno_ENXIO)
1297 #ifdef ENXIO
1298                 {*r = ENXIO; return 0;}
1299 #else /* def ENXIO */
1300                 {errno = EINVAL; return -1;}
1301 #endif /* ndef ENXIO */
1302         if (x == Mono_Posix_Errno_EOPNOTSUPP)
1303 #ifdef EOPNOTSUPP
1304                 {*r = EOPNOTSUPP; return 0;}
1305 #else /* def EOPNOTSUPP */
1306                 {errno = EINVAL; return -1;}
1307 #endif /* ndef EOPNOTSUPP */
1308         if (x == Mono_Posix_Errno_EOVERFLOW)
1309 #ifdef EOVERFLOW
1310                 {*r = EOVERFLOW; return 0;}
1311 #else /* def EOVERFLOW */
1312                 {errno = EINVAL; return -1;}
1313 #endif /* ndef EOVERFLOW */
1314         if (x == Mono_Posix_Errno_EPERM)
1315 #ifdef EPERM
1316                 {*r = EPERM; return 0;}
1317 #else /* def EPERM */
1318                 {errno = EINVAL; return -1;}
1319 #endif /* ndef EPERM */
1320         if (x == Mono_Posix_Errno_EPFNOSUPPORT)
1321 #ifdef EPFNOSUPPORT
1322                 {*r = EPFNOSUPPORT; return 0;}
1323 #else /* def EPFNOSUPPORT */
1324                 {errno = EINVAL; return -1;}
1325 #endif /* ndef EPFNOSUPPORT */
1326         if (x == Mono_Posix_Errno_EPIPE)
1327 #ifdef EPIPE
1328                 {*r = EPIPE; return 0;}
1329 #else /* def EPIPE */
1330                 {errno = EINVAL; return -1;}
1331 #endif /* ndef EPIPE */
1332         if (x == Mono_Posix_Errno_EPROTO)
1333 #ifdef EPROTO
1334                 {*r = EPROTO; return 0;}
1335 #else /* def EPROTO */
1336                 {errno = EINVAL; return -1;}
1337 #endif /* ndef EPROTO */
1338         if (x == Mono_Posix_Errno_EPROTONOSUPPORT)
1339 #ifdef EPROTONOSUPPORT
1340                 {*r = EPROTONOSUPPORT; return 0;}
1341 #else /* def EPROTONOSUPPORT */
1342                 {errno = EINVAL; return -1;}
1343 #endif /* ndef EPROTONOSUPPORT */
1344         if (x == Mono_Posix_Errno_EPROTOTYPE)
1345 #ifdef EPROTOTYPE
1346                 {*r = EPROTOTYPE; return 0;}
1347 #else /* def EPROTOTYPE */
1348                 {errno = EINVAL; return -1;}
1349 #endif /* ndef EPROTOTYPE */
1350         if (x == Mono_Posix_Errno_ERANGE)
1351 #ifdef ERANGE
1352                 {*r = ERANGE; return 0;}
1353 #else /* def ERANGE */
1354                 {errno = EINVAL; return -1;}
1355 #endif /* ndef ERANGE */
1356         if (x == Mono_Posix_Errno_EREMCHG)
1357 #ifdef EREMCHG
1358                 {*r = EREMCHG; return 0;}
1359 #else /* def EREMCHG */
1360                 {errno = EINVAL; return -1;}
1361 #endif /* ndef EREMCHG */
1362         if (x == Mono_Posix_Errno_EREMOTE)
1363 #ifdef EREMOTE
1364                 {*r = EREMOTE; return 0;}
1365 #else /* def EREMOTE */
1366                 {errno = EINVAL; return -1;}
1367 #endif /* ndef EREMOTE */
1368         if (x == Mono_Posix_Errno_EREMOTEIO)
1369 #ifdef EREMOTEIO
1370                 {*r = EREMOTEIO; return 0;}
1371 #else /* def EREMOTEIO */
1372                 {errno = EINVAL; return -1;}
1373 #endif /* ndef EREMOTEIO */
1374         if (x == Mono_Posix_Errno_ERESTART)
1375 #ifdef ERESTART
1376                 {*r = ERESTART; return 0;}
1377 #else /* def ERESTART */
1378                 {errno = EINVAL; return -1;}
1379 #endif /* ndef ERESTART */
1380         if (x == Mono_Posix_Errno_EROFS)
1381 #ifdef EROFS
1382                 {*r = EROFS; return 0;}
1383 #else /* def EROFS */
1384                 {errno = EINVAL; return -1;}
1385 #endif /* ndef EROFS */
1386         if (x == Mono_Posix_Errno_ESHUTDOWN)
1387 #ifdef ESHUTDOWN
1388                 {*r = ESHUTDOWN; return 0;}
1389 #else /* def ESHUTDOWN */
1390                 {errno = EINVAL; return -1;}
1391 #endif /* ndef ESHUTDOWN */
1392         if (x == Mono_Posix_Errno_ESOCKTNOSUPPORT)
1393 #ifdef ESOCKTNOSUPPORT
1394                 {*r = ESOCKTNOSUPPORT; return 0;}
1395 #else /* def ESOCKTNOSUPPORT */
1396                 {errno = EINVAL; return -1;}
1397 #endif /* ndef ESOCKTNOSUPPORT */
1398         if (x == Mono_Posix_Errno_ESPIPE)
1399 #ifdef ESPIPE
1400                 {*r = ESPIPE; return 0;}
1401 #else /* def ESPIPE */
1402                 {errno = EINVAL; return -1;}
1403 #endif /* ndef ESPIPE */
1404         if (x == Mono_Posix_Errno_ESRCH)
1405 #ifdef ESRCH
1406                 {*r = ESRCH; return 0;}
1407 #else /* def ESRCH */
1408                 {errno = EINVAL; return -1;}
1409 #endif /* ndef ESRCH */
1410         if (x == Mono_Posix_Errno_ESRMNT)
1411 #ifdef ESRMNT
1412                 {*r = ESRMNT; return 0;}
1413 #else /* def ESRMNT */
1414                 {errno = EINVAL; return -1;}
1415 #endif /* ndef ESRMNT */
1416         if (x == Mono_Posix_Errno_ESTALE)
1417 #ifdef ESTALE
1418                 {*r = ESTALE; return 0;}
1419 #else /* def ESTALE */
1420                 {errno = EINVAL; return -1;}
1421 #endif /* ndef ESTALE */
1422         if (x == Mono_Posix_Errno_ESTRPIPE)
1423 #ifdef ESTRPIPE
1424                 {*r = ESTRPIPE; return 0;}
1425 #else /* def ESTRPIPE */
1426                 {errno = EINVAL; return -1;}
1427 #endif /* ndef ESTRPIPE */
1428         if (x == Mono_Posix_Errno_ETIME)
1429 #ifdef ETIME
1430                 {*r = ETIME; return 0;}
1431 #else /* def ETIME */
1432                 {errno = EINVAL; return -1;}
1433 #endif /* ndef ETIME */
1434         if (x == Mono_Posix_Errno_ETIMEDOUT)
1435 #ifdef ETIMEDOUT
1436                 {*r = ETIMEDOUT; return 0;}
1437 #else /* def ETIMEDOUT */
1438                 {errno = EINVAL; return -1;}
1439 #endif /* ndef ETIMEDOUT */
1440         if (x == Mono_Posix_Errno_ETOOMANYREFS)
1441 #ifdef ETOOMANYREFS
1442                 {*r = ETOOMANYREFS; return 0;}
1443 #else /* def ETOOMANYREFS */
1444                 {errno = EINVAL; return -1;}
1445 #endif /* ndef ETOOMANYREFS */
1446         if (x == Mono_Posix_Errno_ETXTBSY)
1447 #ifdef ETXTBSY
1448                 {*r = ETXTBSY; return 0;}
1449 #else /* def ETXTBSY */
1450                 {errno = EINVAL; return -1;}
1451 #endif /* ndef ETXTBSY */
1452         if (x == Mono_Posix_Errno_EUCLEAN)
1453 #ifdef EUCLEAN
1454                 {*r = EUCLEAN; return 0;}
1455 #else /* def EUCLEAN */
1456                 {errno = EINVAL; return -1;}
1457 #endif /* ndef EUCLEAN */
1458         if (x == Mono_Posix_Errno_EUNATCH)
1459 #ifdef EUNATCH
1460                 {*r = EUNATCH; return 0;}
1461 #else /* def EUNATCH */
1462                 {errno = EINVAL; return -1;}
1463 #endif /* ndef EUNATCH */
1464         if (x == Mono_Posix_Errno_EUSERS)
1465 #ifdef EUSERS
1466                 {*r = EUSERS; return 0;}
1467 #else /* def EUSERS */
1468                 {errno = EINVAL; return -1;}
1469 #endif /* ndef EUSERS */
1470         if (x == Mono_Posix_Errno_EWOULDBLOCK)
1471 #ifdef EWOULDBLOCK
1472                 {*r = EWOULDBLOCK; return 0;}
1473 #else /* def EWOULDBLOCK */
1474                 {errno = EINVAL; return -1;}
1475 #endif /* ndef EWOULDBLOCK */
1476         if (x == Mono_Posix_Errno_EXDEV)
1477 #ifdef EXDEV
1478                 {*r = EXDEV; return 0;}
1479 #else /* def EXDEV */
1480                 {errno = EINVAL; return -1;}
1481 #endif /* ndef EXDEV */
1482         if (x == Mono_Posix_Errno_EXFULL)
1483 #ifdef EXFULL
1484                 {*r = EXFULL; return 0;}
1485 #else /* def EXFULL */
1486                 {errno = EINVAL; return -1;}
1487 #endif /* ndef EXFULL */
1488         if (x == 0)
1489                 return 0;
1490         errno = EINVAL; return -1;
1491 }
1492
1493 int Mono_Posix_ToErrno (int x, int *r)
1494 {
1495         *r = 0;
1496         if (x == 0)
1497                 return 0;
1498 #ifdef E2BIG
1499         if (x == E2BIG)
1500                 {*r = Mono_Posix_Errno_E2BIG; return 0;}
1501 #endif /* ndef E2BIG */
1502 #ifdef EACCES
1503         if (x == EACCES)
1504                 {*r = Mono_Posix_Errno_EACCES; return 0;}
1505 #endif /* ndef EACCES */
1506 #ifdef EADDRINUSE
1507         if (x == EADDRINUSE)
1508                 {*r = Mono_Posix_Errno_EADDRINUSE; return 0;}
1509 #endif /* ndef EADDRINUSE */
1510 #ifdef EADDRNOTAVAIL
1511         if (x == EADDRNOTAVAIL)
1512                 {*r = Mono_Posix_Errno_EADDRNOTAVAIL; return 0;}
1513 #endif /* ndef EADDRNOTAVAIL */
1514 #ifdef EADV
1515         if (x == EADV)
1516                 {*r = Mono_Posix_Errno_EADV; return 0;}
1517 #endif /* ndef EADV */
1518 #ifdef EAFNOSUPPORT
1519         if (x == EAFNOSUPPORT)
1520                 {*r = Mono_Posix_Errno_EAFNOSUPPORT; return 0;}
1521 #endif /* ndef EAFNOSUPPORT */
1522 #ifdef EAGAIN
1523         if (x == EAGAIN)
1524                 {*r = Mono_Posix_Errno_EAGAIN; return 0;}
1525 #endif /* ndef EAGAIN */
1526 #ifdef EALREADY
1527         if (x == EALREADY)
1528                 {*r = Mono_Posix_Errno_EALREADY; return 0;}
1529 #endif /* ndef EALREADY */
1530 #ifdef EBADE
1531         if (x == EBADE)
1532                 {*r = Mono_Posix_Errno_EBADE; return 0;}
1533 #endif /* ndef EBADE */
1534 #ifdef EBADF
1535         if (x == EBADF)
1536                 {*r = Mono_Posix_Errno_EBADF; return 0;}
1537 #endif /* ndef EBADF */
1538 #ifdef EBADFD
1539         if (x == EBADFD)
1540                 {*r = Mono_Posix_Errno_EBADFD; return 0;}
1541 #endif /* ndef EBADFD */
1542 #ifdef EBADMSG
1543         if (x == EBADMSG)
1544                 {*r = Mono_Posix_Errno_EBADMSG; return 0;}
1545 #endif /* ndef EBADMSG */
1546 #ifdef EBADR
1547         if (x == EBADR)
1548                 {*r = Mono_Posix_Errno_EBADR; return 0;}
1549 #endif /* ndef EBADR */
1550 #ifdef EBADRQC
1551         if (x == EBADRQC)
1552                 {*r = Mono_Posix_Errno_EBADRQC; return 0;}
1553 #endif /* ndef EBADRQC */
1554 #ifdef EBADSLT
1555         if (x == EBADSLT)
1556                 {*r = Mono_Posix_Errno_EBADSLT; return 0;}
1557 #endif /* ndef EBADSLT */
1558 #ifdef EBFONT
1559         if (x == EBFONT)
1560                 {*r = Mono_Posix_Errno_EBFONT; return 0;}
1561 #endif /* ndef EBFONT */
1562 #ifdef EBUSY
1563         if (x == EBUSY)
1564                 {*r = Mono_Posix_Errno_EBUSY; return 0;}
1565 #endif /* ndef EBUSY */
1566 #ifdef ECHILD
1567         if (x == ECHILD)
1568                 {*r = Mono_Posix_Errno_ECHILD; return 0;}
1569 #endif /* ndef ECHILD */
1570 #ifdef ECHRNG
1571         if (x == ECHRNG)
1572                 {*r = Mono_Posix_Errno_ECHRNG; return 0;}
1573 #endif /* ndef ECHRNG */
1574 #ifdef ECOMM
1575         if (x == ECOMM)
1576                 {*r = Mono_Posix_Errno_ECOMM; return 0;}
1577 #endif /* ndef ECOMM */
1578 #ifdef ECONNABORTED
1579         if (x == ECONNABORTED)
1580                 {*r = Mono_Posix_Errno_ECONNABORTED; return 0;}
1581 #endif /* ndef ECONNABORTED */
1582 #ifdef ECONNREFUSED
1583         if (x == ECONNREFUSED)
1584                 {*r = Mono_Posix_Errno_ECONNREFUSED; return 0;}
1585 #endif /* ndef ECONNREFUSED */
1586 #ifdef ECONNRESET
1587         if (x == ECONNRESET)
1588                 {*r = Mono_Posix_Errno_ECONNRESET; return 0;}
1589 #endif /* ndef ECONNRESET */
1590 #ifdef EDEADLK
1591         if (x == EDEADLK)
1592                 {*r = Mono_Posix_Errno_EDEADLK; return 0;}
1593 #endif /* ndef EDEADLK */
1594 #ifdef EDEADLOCK
1595         if (x == EDEADLOCK)
1596                 {*r = Mono_Posix_Errno_EDEADLOCK; return 0;}
1597 #endif /* ndef EDEADLOCK */
1598 #ifdef EDESTADDRREQ
1599         if (x == EDESTADDRREQ)
1600                 {*r = Mono_Posix_Errno_EDESTADDRREQ; return 0;}
1601 #endif /* ndef EDESTADDRREQ */
1602 #ifdef EDOM
1603         if (x == EDOM)
1604                 {*r = Mono_Posix_Errno_EDOM; return 0;}
1605 #endif /* ndef EDOM */
1606 #ifdef EDOTDOT
1607         if (x == EDOTDOT)
1608                 {*r = Mono_Posix_Errno_EDOTDOT; return 0;}
1609 #endif /* ndef EDOTDOT */
1610 #ifdef EDQUOT
1611         if (x == EDQUOT)
1612                 {*r = Mono_Posix_Errno_EDQUOT; return 0;}
1613 #endif /* ndef EDQUOT */
1614 #ifdef EEXIST
1615         if (x == EEXIST)
1616                 {*r = Mono_Posix_Errno_EEXIST; return 0;}
1617 #endif /* ndef EEXIST */
1618 #ifdef EFAULT
1619         if (x == EFAULT)
1620                 {*r = Mono_Posix_Errno_EFAULT; return 0;}
1621 #endif /* ndef EFAULT */
1622 #ifdef EFBIG
1623         if (x == EFBIG)
1624                 {*r = Mono_Posix_Errno_EFBIG; return 0;}
1625 #endif /* ndef EFBIG */
1626 #ifdef EHOSTDOWN
1627         if (x == EHOSTDOWN)
1628                 {*r = Mono_Posix_Errno_EHOSTDOWN; return 0;}
1629 #endif /* ndef EHOSTDOWN */
1630 #ifdef EHOSTUNREACH
1631         if (x == EHOSTUNREACH)
1632                 {*r = Mono_Posix_Errno_EHOSTUNREACH; return 0;}
1633 #endif /* ndef EHOSTUNREACH */
1634 #ifdef EIDRM
1635         if (x == EIDRM)
1636                 {*r = Mono_Posix_Errno_EIDRM; return 0;}
1637 #endif /* ndef EIDRM */
1638 #ifdef EILSEQ
1639         if (x == EILSEQ)
1640                 {*r = Mono_Posix_Errno_EILSEQ; return 0;}
1641 #endif /* ndef EILSEQ */
1642 #ifdef EINPROGRESS
1643         if (x == EINPROGRESS)
1644                 {*r = Mono_Posix_Errno_EINPROGRESS; return 0;}
1645 #endif /* ndef EINPROGRESS */
1646 #ifdef EINTR
1647         if (x == EINTR)
1648                 {*r = Mono_Posix_Errno_EINTR; return 0;}
1649 #endif /* ndef EINTR */
1650 #ifdef EINVAL
1651         if (x == EINVAL)
1652                 {*r = Mono_Posix_Errno_EINVAL; return 0;}
1653 #endif /* ndef EINVAL */
1654 #ifdef EIO
1655         if (x == EIO)
1656                 {*r = Mono_Posix_Errno_EIO; return 0;}
1657 #endif /* ndef EIO */
1658 #ifdef EISCONN
1659         if (x == EISCONN)
1660                 {*r = Mono_Posix_Errno_EISCONN; return 0;}
1661 #endif /* ndef EISCONN */
1662 #ifdef EISDIR
1663         if (x == EISDIR)
1664                 {*r = Mono_Posix_Errno_EISDIR; return 0;}
1665 #endif /* ndef EISDIR */
1666 #ifdef EISNAM
1667         if (x == EISNAM)
1668                 {*r = Mono_Posix_Errno_EISNAM; return 0;}
1669 #endif /* ndef EISNAM */
1670 #ifdef EL2HLT
1671         if (x == EL2HLT)
1672                 {*r = Mono_Posix_Errno_EL2HLT; return 0;}
1673 #endif /* ndef EL2HLT */
1674 #ifdef EL2NSYNC
1675         if (x == EL2NSYNC)
1676                 {*r = Mono_Posix_Errno_EL2NSYNC; return 0;}
1677 #endif /* ndef EL2NSYNC */
1678 #ifdef EL3HLT
1679         if (x == EL3HLT)
1680                 {*r = Mono_Posix_Errno_EL3HLT; return 0;}
1681 #endif /* ndef EL3HLT */
1682 #ifdef EL3RST
1683         if (x == EL3RST)
1684                 {*r = Mono_Posix_Errno_EL3RST; return 0;}
1685 #endif /* ndef EL3RST */
1686 #ifdef ELIBACC
1687         if (x == ELIBACC)
1688                 {*r = Mono_Posix_Errno_ELIBACC; return 0;}
1689 #endif /* ndef ELIBACC */
1690 #ifdef ELIBBAD
1691         if (x == ELIBBAD)
1692                 {*r = Mono_Posix_Errno_ELIBBAD; return 0;}
1693 #endif /* ndef ELIBBAD */
1694 #ifdef ELIBEXEC
1695         if (x == ELIBEXEC)
1696                 {*r = Mono_Posix_Errno_ELIBEXEC; return 0;}
1697 #endif /* ndef ELIBEXEC */
1698 #ifdef ELIBMAX
1699         if (x == ELIBMAX)
1700                 {*r = Mono_Posix_Errno_ELIBMAX; return 0;}
1701 #endif /* ndef ELIBMAX */
1702 #ifdef ELIBSCN
1703         if (x == ELIBSCN)
1704                 {*r = Mono_Posix_Errno_ELIBSCN; return 0;}
1705 #endif /* ndef ELIBSCN */
1706 #ifdef ELNRNG
1707         if (x == ELNRNG)
1708                 {*r = Mono_Posix_Errno_ELNRNG; return 0;}
1709 #endif /* ndef ELNRNG */
1710 #ifdef ELOOP
1711         if (x == ELOOP)
1712                 {*r = Mono_Posix_Errno_ELOOP; return 0;}
1713 #endif /* ndef ELOOP */
1714 #ifdef EMEDIUMTYPE
1715         if (x == EMEDIUMTYPE)
1716                 {*r = Mono_Posix_Errno_EMEDIUMTYPE; return 0;}
1717 #endif /* ndef EMEDIUMTYPE */
1718 #ifdef EMFILE
1719         if (x == EMFILE)
1720                 {*r = Mono_Posix_Errno_EMFILE; return 0;}
1721 #endif /* ndef EMFILE */
1722 #ifdef EMLINK
1723         if (x == EMLINK)
1724                 {*r = Mono_Posix_Errno_EMLINK; return 0;}
1725 #endif /* ndef EMLINK */
1726 #ifdef EMSGSIZE
1727         if (x == EMSGSIZE)
1728                 {*r = Mono_Posix_Errno_EMSGSIZE; return 0;}
1729 #endif /* ndef EMSGSIZE */
1730 #ifdef EMULTIHOP
1731         if (x == EMULTIHOP)
1732                 {*r = Mono_Posix_Errno_EMULTIHOP; return 0;}
1733 #endif /* ndef EMULTIHOP */
1734 #ifdef ENAMETOOLONG
1735         if (x == ENAMETOOLONG)
1736                 {*r = Mono_Posix_Errno_ENAMETOOLONG; return 0;}
1737 #endif /* ndef ENAMETOOLONG */
1738 #ifdef ENAVAIL
1739         if (x == ENAVAIL)
1740                 {*r = Mono_Posix_Errno_ENAVAIL; return 0;}
1741 #endif /* ndef ENAVAIL */
1742 #ifdef ENETDOWN
1743         if (x == ENETDOWN)
1744                 {*r = Mono_Posix_Errno_ENETDOWN; return 0;}
1745 #endif /* ndef ENETDOWN */
1746 #ifdef ENETRESET
1747         if (x == ENETRESET)
1748                 {*r = Mono_Posix_Errno_ENETRESET; return 0;}
1749 #endif /* ndef ENETRESET */
1750 #ifdef ENETUNREACH
1751         if (x == ENETUNREACH)
1752                 {*r = Mono_Posix_Errno_ENETUNREACH; return 0;}
1753 #endif /* ndef ENETUNREACH */
1754 #ifdef ENFILE
1755         if (x == ENFILE)
1756                 {*r = Mono_Posix_Errno_ENFILE; return 0;}
1757 #endif /* ndef ENFILE */
1758 #ifdef ENOANO
1759         if (x == ENOANO)
1760                 {*r = Mono_Posix_Errno_ENOANO; return 0;}
1761 #endif /* ndef ENOANO */
1762 #ifdef ENOBUFS
1763         if (x == ENOBUFS)
1764                 {*r = Mono_Posix_Errno_ENOBUFS; return 0;}
1765 #endif /* ndef ENOBUFS */
1766 #ifdef ENOCSI
1767         if (x == ENOCSI)
1768                 {*r = Mono_Posix_Errno_ENOCSI; return 0;}
1769 #endif /* ndef ENOCSI */
1770 #ifdef ENODATA
1771         if (x == ENODATA)
1772                 {*r = Mono_Posix_Errno_ENODATA; return 0;}
1773 #endif /* ndef ENODATA */
1774 #ifdef ENODEV
1775         if (x == ENODEV)
1776                 {*r = Mono_Posix_Errno_ENODEV; return 0;}
1777 #endif /* ndef ENODEV */
1778 #ifdef ENOENT
1779         if (x == ENOENT)
1780                 {*r = Mono_Posix_Errno_ENOENT; return 0;}
1781 #endif /* ndef ENOENT */
1782 #ifdef ENOEXEC
1783         if (x == ENOEXEC)
1784                 {*r = Mono_Posix_Errno_ENOEXEC; return 0;}
1785 #endif /* ndef ENOEXEC */
1786 #ifdef ENOLCK
1787         if (x == ENOLCK)
1788                 {*r = Mono_Posix_Errno_ENOLCK; return 0;}
1789 #endif /* ndef ENOLCK */
1790 #ifdef ENOLINK
1791         if (x == ENOLINK)
1792                 {*r = Mono_Posix_Errno_ENOLINK; return 0;}
1793 #endif /* ndef ENOLINK */
1794 #ifdef ENOMEDIUM
1795         if (x == ENOMEDIUM)
1796                 {*r = Mono_Posix_Errno_ENOMEDIUM; return 0;}
1797 #endif /* ndef ENOMEDIUM */
1798 #ifdef ENOMEM
1799         if (x == ENOMEM)
1800                 {*r = Mono_Posix_Errno_ENOMEM; return 0;}
1801 #endif /* ndef ENOMEM */
1802 #ifdef ENOMSG
1803         if (x == ENOMSG)
1804                 {*r = Mono_Posix_Errno_ENOMSG; return 0;}
1805 #endif /* ndef ENOMSG */
1806 #ifdef ENONET
1807         if (x == ENONET)
1808                 {*r = Mono_Posix_Errno_ENONET; return 0;}
1809 #endif /* ndef ENONET */
1810 #ifdef ENOPKG
1811         if (x == ENOPKG)
1812                 {*r = Mono_Posix_Errno_ENOPKG; return 0;}
1813 #endif /* ndef ENOPKG */
1814 #ifdef ENOPROTOOPT
1815         if (x == ENOPROTOOPT)
1816                 {*r = Mono_Posix_Errno_ENOPROTOOPT; return 0;}
1817 #endif /* ndef ENOPROTOOPT */
1818 #ifdef ENOSPC
1819         if (x == ENOSPC)
1820                 {*r = Mono_Posix_Errno_ENOSPC; return 0;}
1821 #endif /* ndef ENOSPC */
1822 #ifdef ENOSR
1823         if (x == ENOSR)
1824                 {*r = Mono_Posix_Errno_ENOSR; return 0;}
1825 #endif /* ndef ENOSR */
1826 #ifdef ENOSTR
1827         if (x == ENOSTR)
1828                 {*r = Mono_Posix_Errno_ENOSTR; return 0;}
1829 #endif /* ndef ENOSTR */
1830 #ifdef ENOSYS
1831         if (x == ENOSYS)
1832                 {*r = Mono_Posix_Errno_ENOSYS; return 0;}
1833 #endif /* ndef ENOSYS */
1834 #ifdef ENOTBLK
1835         if (x == ENOTBLK)
1836                 {*r = Mono_Posix_Errno_ENOTBLK; return 0;}
1837 #endif /* ndef ENOTBLK */
1838 #ifdef ENOTCONN
1839         if (x == ENOTCONN)
1840                 {*r = Mono_Posix_Errno_ENOTCONN; return 0;}
1841 #endif /* ndef ENOTCONN */
1842 #ifdef ENOTDIR
1843         if (x == ENOTDIR)
1844                 {*r = Mono_Posix_Errno_ENOTDIR; return 0;}
1845 #endif /* ndef ENOTDIR */
1846 #ifdef ENOTEMPTY
1847         if (x == ENOTEMPTY)
1848                 {*r = Mono_Posix_Errno_ENOTEMPTY; return 0;}
1849 #endif /* ndef ENOTEMPTY */
1850 #ifdef ENOTNAM
1851         if (x == ENOTNAM)
1852                 {*r = Mono_Posix_Errno_ENOTNAM; return 0;}
1853 #endif /* ndef ENOTNAM */
1854 #ifdef ENOTSOCK
1855         if (x == ENOTSOCK)
1856                 {*r = Mono_Posix_Errno_ENOTSOCK; return 0;}
1857 #endif /* ndef ENOTSOCK */
1858 #ifdef ENOTTY
1859         if (x == ENOTTY)
1860                 {*r = Mono_Posix_Errno_ENOTTY; return 0;}
1861 #endif /* ndef ENOTTY */
1862 #ifdef ENOTUNIQ
1863         if (x == ENOTUNIQ)
1864                 {*r = Mono_Posix_Errno_ENOTUNIQ; return 0;}
1865 #endif /* ndef ENOTUNIQ */
1866 #ifdef ENXIO
1867         if (x == ENXIO)
1868                 {*r = Mono_Posix_Errno_ENXIO; return 0;}
1869 #endif /* ndef ENXIO */
1870 #ifdef EOPNOTSUPP
1871         if (x == EOPNOTSUPP)
1872                 {*r = Mono_Posix_Errno_EOPNOTSUPP; return 0;}
1873 #endif /* ndef EOPNOTSUPP */
1874 #ifdef EOVERFLOW
1875         if (x == EOVERFLOW)
1876                 {*r = Mono_Posix_Errno_EOVERFLOW; return 0;}
1877 #endif /* ndef EOVERFLOW */
1878 #ifdef EPERM
1879         if (x == EPERM)
1880                 {*r = Mono_Posix_Errno_EPERM; return 0;}
1881 #endif /* ndef EPERM */
1882 #ifdef EPFNOSUPPORT
1883         if (x == EPFNOSUPPORT)
1884                 {*r = Mono_Posix_Errno_EPFNOSUPPORT; return 0;}
1885 #endif /* ndef EPFNOSUPPORT */
1886 #ifdef EPIPE
1887         if (x == EPIPE)
1888                 {*r = Mono_Posix_Errno_EPIPE; return 0;}
1889 #endif /* ndef EPIPE */
1890 #ifdef EPROTO
1891         if (x == EPROTO)
1892                 {*r = Mono_Posix_Errno_EPROTO; return 0;}
1893 #endif /* ndef EPROTO */
1894 #ifdef EPROTONOSUPPORT
1895         if (x == EPROTONOSUPPORT)
1896                 {*r = Mono_Posix_Errno_EPROTONOSUPPORT; return 0;}
1897 #endif /* ndef EPROTONOSUPPORT */
1898 #ifdef EPROTOTYPE
1899         if (x == EPROTOTYPE)
1900                 {*r = Mono_Posix_Errno_EPROTOTYPE; return 0;}
1901 #endif /* ndef EPROTOTYPE */
1902 #ifdef ERANGE
1903         if (x == ERANGE)
1904                 {*r = Mono_Posix_Errno_ERANGE; return 0;}
1905 #endif /* ndef ERANGE */
1906 #ifdef EREMCHG
1907         if (x == EREMCHG)
1908                 {*r = Mono_Posix_Errno_EREMCHG; return 0;}
1909 #endif /* ndef EREMCHG */
1910 #ifdef EREMOTE
1911         if (x == EREMOTE)
1912                 {*r = Mono_Posix_Errno_EREMOTE; return 0;}
1913 #endif /* ndef EREMOTE */
1914 #ifdef EREMOTEIO
1915         if (x == EREMOTEIO)
1916                 {*r = Mono_Posix_Errno_EREMOTEIO; return 0;}
1917 #endif /* ndef EREMOTEIO */
1918 #ifdef ERESTART
1919         if (x == ERESTART)
1920                 {*r = Mono_Posix_Errno_ERESTART; return 0;}
1921 #endif /* ndef ERESTART */
1922 #ifdef EROFS
1923         if (x == EROFS)
1924                 {*r = Mono_Posix_Errno_EROFS; return 0;}
1925 #endif /* ndef EROFS */
1926 #ifdef ESHUTDOWN
1927         if (x == ESHUTDOWN)
1928                 {*r = Mono_Posix_Errno_ESHUTDOWN; return 0;}
1929 #endif /* ndef ESHUTDOWN */
1930 #ifdef ESOCKTNOSUPPORT
1931         if (x == ESOCKTNOSUPPORT)
1932                 {*r = Mono_Posix_Errno_ESOCKTNOSUPPORT; return 0;}
1933 #endif /* ndef ESOCKTNOSUPPORT */
1934 #ifdef ESPIPE
1935         if (x == ESPIPE)
1936                 {*r = Mono_Posix_Errno_ESPIPE; return 0;}
1937 #endif /* ndef ESPIPE */
1938 #ifdef ESRCH
1939         if (x == ESRCH)
1940                 {*r = Mono_Posix_Errno_ESRCH; return 0;}
1941 #endif /* ndef ESRCH */
1942 #ifdef ESRMNT
1943         if (x == ESRMNT)
1944                 {*r = Mono_Posix_Errno_ESRMNT; return 0;}
1945 #endif /* ndef ESRMNT */
1946 #ifdef ESTALE
1947         if (x == ESTALE)
1948                 {*r = Mono_Posix_Errno_ESTALE; return 0;}
1949 #endif /* ndef ESTALE */
1950 #ifdef ESTRPIPE
1951         if (x == ESTRPIPE)
1952                 {*r = Mono_Posix_Errno_ESTRPIPE; return 0;}
1953 #endif /* ndef ESTRPIPE */
1954 #ifdef ETIME
1955         if (x == ETIME)
1956                 {*r = Mono_Posix_Errno_ETIME; return 0;}
1957 #endif /* ndef ETIME */
1958 #ifdef ETIMEDOUT
1959         if (x == ETIMEDOUT)
1960                 {*r = Mono_Posix_Errno_ETIMEDOUT; return 0;}
1961 #endif /* ndef ETIMEDOUT */
1962 #ifdef ETOOMANYREFS
1963         if (x == ETOOMANYREFS)
1964                 {*r = Mono_Posix_Errno_ETOOMANYREFS; return 0;}
1965 #endif /* ndef ETOOMANYREFS */
1966 #ifdef ETXTBSY
1967         if (x == ETXTBSY)
1968                 {*r = Mono_Posix_Errno_ETXTBSY; return 0;}
1969 #endif /* ndef ETXTBSY */
1970 #ifdef EUCLEAN
1971         if (x == EUCLEAN)
1972                 {*r = Mono_Posix_Errno_EUCLEAN; return 0;}
1973 #endif /* ndef EUCLEAN */
1974 #ifdef EUNATCH
1975         if (x == EUNATCH)
1976                 {*r = Mono_Posix_Errno_EUNATCH; return 0;}
1977 #endif /* ndef EUNATCH */
1978 #ifdef EUSERS
1979         if (x == EUSERS)
1980                 {*r = Mono_Posix_Errno_EUSERS; return 0;}
1981 #endif /* ndef EUSERS */
1982 #ifdef EWOULDBLOCK
1983         if (x == EWOULDBLOCK)
1984                 {*r = Mono_Posix_Errno_EWOULDBLOCK; return 0;}
1985 #endif /* ndef EWOULDBLOCK */
1986 #ifdef EXDEV
1987         if (x == EXDEV)
1988                 {*r = Mono_Posix_Errno_EXDEV; return 0;}
1989 #endif /* ndef EXDEV */
1990 #ifdef EXFULL
1991         if (x == EXFULL)
1992                 {*r = Mono_Posix_Errno_EXFULL; return 0;}
1993 #endif /* ndef EXFULL */
1994         errno = EINVAL; return -1;
1995 }
1996
1997 int Mono_Posix_FromFcntlCommand (int x, int *r)
1998 {
1999         *r = 0;
2000         if (x == Mono_Posix_FcntlCommand_F_DUPFD)
2001 #ifdef F_DUPFD
2002                 {*r = F_DUPFD; return 0;}
2003 #else /* def F_DUPFD */
2004                 {errno = EINVAL; return -1;}
2005 #endif /* ndef F_DUPFD */
2006         if (x == Mono_Posix_FcntlCommand_F_GETFD)
2007 #ifdef F_GETFD
2008                 {*r = F_GETFD; return 0;}
2009 #else /* def F_GETFD */
2010                 {errno = EINVAL; return -1;}
2011 #endif /* ndef F_GETFD */
2012         if (x == Mono_Posix_FcntlCommand_F_GETFL)
2013 #ifdef F_GETFL
2014                 {*r = F_GETFL; return 0;}
2015 #else /* def F_GETFL */
2016                 {errno = EINVAL; return -1;}
2017 #endif /* ndef F_GETFL */
2018         if (x == Mono_Posix_FcntlCommand_F_GETLEASE)
2019 #ifdef F_GETLEASE
2020                 {*r = F_GETLEASE; return 0;}
2021 #else /* def F_GETLEASE */
2022                 {errno = EINVAL; return -1;}
2023 #endif /* ndef F_GETLEASE */
2024         if (x == Mono_Posix_FcntlCommand_F_GETLK)
2025 #ifdef F_GETLK
2026                 {*r = F_GETLK; return 0;}
2027 #else /* def F_GETLK */
2028                 {errno = EINVAL; return -1;}
2029 #endif /* ndef F_GETLK */
2030         if (x == Mono_Posix_FcntlCommand_F_GETOWN)
2031 #ifdef F_GETOWN
2032                 {*r = F_GETOWN; return 0;}
2033 #else /* def F_GETOWN */
2034                 {errno = EINVAL; return -1;}
2035 #endif /* ndef F_GETOWN */
2036         if (x == Mono_Posix_FcntlCommand_F_GETSIG)
2037 #ifdef F_GETSIG
2038                 {*r = F_GETSIG; return 0;}
2039 #else /* def F_GETSIG */
2040                 {errno = EINVAL; return -1;}
2041 #endif /* ndef F_GETSIG */
2042         if (x == Mono_Posix_FcntlCommand_F_NOTIFY)
2043 #ifdef F_NOTIFY
2044                 {*r = F_NOTIFY; return 0;}
2045 #else /* def F_NOTIFY */
2046                 {errno = EINVAL; return -1;}
2047 #endif /* ndef F_NOTIFY */
2048         if (x == Mono_Posix_FcntlCommand_F_SETFD)
2049 #ifdef F_SETFD
2050                 {*r = F_SETFD; return 0;}
2051 #else /* def F_SETFD */
2052                 {errno = EINVAL; return -1;}
2053 #endif /* ndef F_SETFD */
2054         if (x == Mono_Posix_FcntlCommand_F_SETFL)
2055 #ifdef F_SETFL
2056                 {*r = F_SETFL; return 0;}
2057 #else /* def F_SETFL */
2058                 {errno = EINVAL; return -1;}
2059 #endif /* ndef F_SETFL */
2060         if (x == Mono_Posix_FcntlCommand_F_SETLEASE)
2061 #ifdef F_SETLEASE
2062                 {*r = F_SETLEASE; return 0;}
2063 #else /* def F_SETLEASE */
2064                 {errno = EINVAL; return -1;}
2065 #endif /* ndef F_SETLEASE */
2066         if (x == Mono_Posix_FcntlCommand_F_SETLK)
2067 #ifdef F_SETLK
2068                 {*r = F_SETLK; return 0;}
2069 #else /* def F_SETLK */
2070                 {errno = EINVAL; return -1;}
2071 #endif /* ndef F_SETLK */
2072         if (x == Mono_Posix_FcntlCommand_F_SETLKW)
2073 #ifdef F_SETLKW
2074                 {*r = F_SETLKW; return 0;}
2075 #else /* def F_SETLKW */
2076                 {errno = EINVAL; return -1;}
2077 #endif /* ndef F_SETLKW */
2078         if (x == Mono_Posix_FcntlCommand_F_SETOWN)
2079 #ifdef F_SETOWN
2080                 {*r = F_SETOWN; return 0;}
2081 #else /* def F_SETOWN */
2082                 {errno = EINVAL; return -1;}
2083 #endif /* ndef F_SETOWN */
2084         if (x == Mono_Posix_FcntlCommand_F_SETSIG)
2085 #ifdef F_SETSIG
2086                 {*r = F_SETSIG; return 0;}
2087 #else /* def F_SETSIG */
2088                 {errno = EINVAL; return -1;}
2089 #endif /* ndef F_SETSIG */
2090         if (x == 0)
2091                 return 0;
2092         errno = EINVAL; return -1;
2093 }
2094
2095 int Mono_Posix_ToFcntlCommand (int x, int *r)
2096 {
2097         *r = 0;
2098         if (x == 0)
2099                 return 0;
2100 #ifdef F_DUPFD
2101         if (x == F_DUPFD)
2102                 {*r = Mono_Posix_FcntlCommand_F_DUPFD; return 0;}
2103 #endif /* ndef F_DUPFD */
2104 #ifdef F_GETFD
2105         if (x == F_GETFD)
2106                 {*r = Mono_Posix_FcntlCommand_F_GETFD; return 0;}
2107 #endif /* ndef F_GETFD */
2108 #ifdef F_GETFL
2109         if (x == F_GETFL)
2110                 {*r = Mono_Posix_FcntlCommand_F_GETFL; return 0;}
2111 #endif /* ndef F_GETFL */
2112 #ifdef F_GETLEASE
2113         if (x == F_GETLEASE)
2114                 {*r = Mono_Posix_FcntlCommand_F_GETLEASE; return 0;}
2115 #endif /* ndef F_GETLEASE */
2116 #ifdef F_GETLK
2117         if (x == F_GETLK)
2118                 {*r = Mono_Posix_FcntlCommand_F_GETLK; return 0;}
2119 #endif /* ndef F_GETLK */
2120 #ifdef F_GETOWN
2121         if (x == F_GETOWN)
2122                 {*r = Mono_Posix_FcntlCommand_F_GETOWN; return 0;}
2123 #endif /* ndef F_GETOWN */
2124 #ifdef F_GETSIG
2125         if (x == F_GETSIG)
2126                 {*r = Mono_Posix_FcntlCommand_F_GETSIG; return 0;}
2127 #endif /* ndef F_GETSIG */
2128 #ifdef F_NOTIFY
2129         if (x == F_NOTIFY)
2130                 {*r = Mono_Posix_FcntlCommand_F_NOTIFY; return 0;}
2131 #endif /* ndef F_NOTIFY */
2132 #ifdef F_SETFD
2133         if (x == F_SETFD)
2134                 {*r = Mono_Posix_FcntlCommand_F_SETFD; return 0;}
2135 #endif /* ndef F_SETFD */
2136 #ifdef F_SETFL
2137         if (x == F_SETFL)
2138                 {*r = Mono_Posix_FcntlCommand_F_SETFL; return 0;}
2139 #endif /* ndef F_SETFL */
2140 #ifdef F_SETLEASE
2141         if (x == F_SETLEASE)
2142                 {*r = Mono_Posix_FcntlCommand_F_SETLEASE; return 0;}
2143 #endif /* ndef F_SETLEASE */
2144 #ifdef F_SETLK
2145         if (x == F_SETLK)
2146                 {*r = Mono_Posix_FcntlCommand_F_SETLK; return 0;}
2147 #endif /* ndef F_SETLK */
2148 #ifdef F_SETLKW
2149         if (x == F_SETLKW)
2150                 {*r = Mono_Posix_FcntlCommand_F_SETLKW; return 0;}
2151 #endif /* ndef F_SETLKW */
2152 #ifdef F_SETOWN
2153         if (x == F_SETOWN)
2154                 {*r = Mono_Posix_FcntlCommand_F_SETOWN; return 0;}
2155 #endif /* ndef F_SETOWN */
2156 #ifdef F_SETSIG
2157         if (x == F_SETSIG)
2158                 {*r = Mono_Posix_FcntlCommand_F_SETSIG; return 0;}
2159 #endif /* ndef F_SETSIG */
2160         errno = EINVAL; return -1;
2161 }
2162
2163 int Mono_Posix_FromFilePermissions (unsigned int x, unsigned int *r)
2164 {
2165         *r = 0;
2166         if ((x & Mono_Posix_FilePermissions_ACCESSPERMS) == Mono_Posix_FilePermissions_ACCESSPERMS)
2167 #ifdef ACCESSPERMS
2168                 *r |= ACCESSPERMS;
2169 #else /* def ACCESSPERMS */
2170                 {errno = EINVAL; return -1;}
2171 #endif /* ndef ACCESSPERMS */
2172         if ((x & Mono_Posix_FilePermissions_ALLPERMS) == Mono_Posix_FilePermissions_ALLPERMS)
2173 #ifdef ALLPERMS
2174                 *r |= ALLPERMS;
2175 #else /* def ALLPERMS */
2176                 {errno = EINVAL; return -1;}
2177 #endif /* ndef ALLPERMS */
2178         if ((x & Mono_Posix_FilePermissions_DEFFILEMODE) == Mono_Posix_FilePermissions_DEFFILEMODE)
2179 #ifdef DEFFILEMODE
2180                 *r |= DEFFILEMODE;
2181 #else /* def DEFFILEMODE */
2182                 {errno = EINVAL; return -1;}
2183 #endif /* ndef DEFFILEMODE */
2184         if ((x & Mono_Posix_FilePermissions_S_IFBLK) == Mono_Posix_FilePermissions_S_IFBLK)
2185 #ifdef S_IFBLK
2186                 *r |= S_IFBLK;
2187 #else /* def S_IFBLK */
2188                 {errno = EINVAL; return -1;}
2189 #endif /* ndef S_IFBLK */
2190         if ((x & Mono_Posix_FilePermissions_S_IFCHR) == Mono_Posix_FilePermissions_S_IFCHR)
2191 #ifdef S_IFCHR
2192                 *r |= S_IFCHR;
2193 #else /* def S_IFCHR */
2194                 {errno = EINVAL; return -1;}
2195 #endif /* ndef S_IFCHR */
2196         if ((x & Mono_Posix_FilePermissions_S_IFDIR) == Mono_Posix_FilePermissions_S_IFDIR)
2197 #ifdef S_IFDIR
2198                 *r |= S_IFDIR;
2199 #else /* def S_IFDIR */
2200                 {errno = EINVAL; return -1;}
2201 #endif /* ndef S_IFDIR */
2202         if ((x & Mono_Posix_FilePermissions_S_IFIFO) == Mono_Posix_FilePermissions_S_IFIFO)
2203 #ifdef S_IFIFO
2204                 *r |= S_IFIFO;
2205 #else /* def S_IFIFO */
2206                 {errno = EINVAL; return -1;}
2207 #endif /* ndef S_IFIFO */
2208         if ((x & Mono_Posix_FilePermissions_S_IFLNK) == Mono_Posix_FilePermissions_S_IFLNK)
2209 #ifdef S_IFLNK
2210                 *r |= S_IFLNK;
2211 #else /* def S_IFLNK */
2212                 {errno = EINVAL; return -1;}
2213 #endif /* ndef S_IFLNK */
2214         if ((x & Mono_Posix_FilePermissions_S_IFMT) == Mono_Posix_FilePermissions_S_IFMT)
2215 #ifdef S_IFMT
2216                 *r |= S_IFMT;
2217 #else /* def S_IFMT */
2218                 {errno = EINVAL; return -1;}
2219 #endif /* ndef S_IFMT */
2220         if ((x & Mono_Posix_FilePermissions_S_IFREG) == Mono_Posix_FilePermissions_S_IFREG)
2221 #ifdef S_IFREG
2222                 *r |= S_IFREG;
2223 #else /* def S_IFREG */
2224                 {errno = EINVAL; return -1;}
2225 #endif /* ndef S_IFREG */
2226         if ((x & Mono_Posix_FilePermissions_S_IFSOCK) == Mono_Posix_FilePermissions_S_IFSOCK)
2227 #ifdef S_IFSOCK
2228                 *r |= S_IFSOCK;
2229 #else /* def S_IFSOCK */
2230                 {errno = EINVAL; return -1;}
2231 #endif /* ndef S_IFSOCK */
2232         if ((x & Mono_Posix_FilePermissions_S_IRGRP) == Mono_Posix_FilePermissions_S_IRGRP)
2233 #ifdef S_IRGRP
2234                 *r |= S_IRGRP;
2235 #else /* def S_IRGRP */
2236                 {errno = EINVAL; return -1;}
2237 #endif /* ndef S_IRGRP */
2238         if ((x & Mono_Posix_FilePermissions_S_IROTH) == Mono_Posix_FilePermissions_S_IROTH)
2239 #ifdef S_IROTH
2240                 *r |= S_IROTH;
2241 #else /* def S_IROTH */
2242                 {errno = EINVAL; return -1;}
2243 #endif /* ndef S_IROTH */
2244         if ((x & Mono_Posix_FilePermissions_S_IRUSR) == Mono_Posix_FilePermissions_S_IRUSR)
2245 #ifdef S_IRUSR
2246                 *r |= S_IRUSR;
2247 #else /* def S_IRUSR */
2248                 {errno = EINVAL; return -1;}
2249 #endif /* ndef S_IRUSR */
2250         if ((x & Mono_Posix_FilePermissions_S_IRWXG) == Mono_Posix_FilePermissions_S_IRWXG)
2251 #ifdef S_IRWXG
2252                 *r |= S_IRWXG;
2253 #else /* def S_IRWXG */
2254                 {errno = EINVAL; return -1;}
2255 #endif /* ndef S_IRWXG */
2256         if ((x & Mono_Posix_FilePermissions_S_IRWXO) == Mono_Posix_FilePermissions_S_IRWXO)
2257 #ifdef S_IRWXO
2258                 *r |= S_IRWXO;
2259 #else /* def S_IRWXO */
2260                 {errno = EINVAL; return -1;}
2261 #endif /* ndef S_IRWXO */
2262         if ((x & Mono_Posix_FilePermissions_S_IRWXU) == Mono_Posix_FilePermissions_S_IRWXU)
2263 #ifdef S_IRWXU
2264                 *r |= S_IRWXU;
2265 #else /* def S_IRWXU */
2266                 {errno = EINVAL; return -1;}
2267 #endif /* ndef S_IRWXU */
2268         if ((x & Mono_Posix_FilePermissions_S_ISGID) == Mono_Posix_FilePermissions_S_ISGID)
2269 #ifdef S_ISGID
2270                 *r |= S_ISGID;
2271 #else /* def S_ISGID */
2272                 {errno = EINVAL; return -1;}
2273 #endif /* ndef S_ISGID */
2274         if ((x & Mono_Posix_FilePermissions_S_ISUID) == Mono_Posix_FilePermissions_S_ISUID)
2275 #ifdef S_ISUID
2276                 *r |= S_ISUID;
2277 #else /* def S_ISUID */
2278                 {errno = EINVAL; return -1;}
2279 #endif /* ndef S_ISUID */
2280         if ((x & Mono_Posix_FilePermissions_S_ISVTX) == Mono_Posix_FilePermissions_S_ISVTX)
2281 #ifdef S_ISVTX
2282                 *r |= S_ISVTX;
2283 #else /* def S_ISVTX */
2284                 {errno = EINVAL; return -1;}
2285 #endif /* ndef S_ISVTX */
2286         if ((x & Mono_Posix_FilePermissions_S_IWGRP) == Mono_Posix_FilePermissions_S_IWGRP)
2287 #ifdef S_IWGRP
2288                 *r |= S_IWGRP;
2289 #else /* def S_IWGRP */
2290                 {errno = EINVAL; return -1;}
2291 #endif /* ndef S_IWGRP */
2292         if ((x & Mono_Posix_FilePermissions_S_IWOTH) == Mono_Posix_FilePermissions_S_IWOTH)
2293 #ifdef S_IWOTH
2294                 *r |= S_IWOTH;
2295 #else /* def S_IWOTH */
2296                 {errno = EINVAL; return -1;}
2297 #endif /* ndef S_IWOTH */
2298         if ((x & Mono_Posix_FilePermissions_S_IWUSR) == Mono_Posix_FilePermissions_S_IWUSR)
2299 #ifdef S_IWUSR
2300                 *r |= S_IWUSR;
2301 #else /* def S_IWUSR */
2302                 {errno = EINVAL; return -1;}
2303 #endif /* ndef S_IWUSR */
2304         if ((x & Mono_Posix_FilePermissions_S_IXGRP) == Mono_Posix_FilePermissions_S_IXGRP)
2305 #ifdef S_IXGRP
2306                 *r |= S_IXGRP;
2307 #else /* def S_IXGRP */
2308                 {errno = EINVAL; return -1;}
2309 #endif /* ndef S_IXGRP */
2310         if ((x & Mono_Posix_FilePermissions_S_IXOTH) == Mono_Posix_FilePermissions_S_IXOTH)
2311 #ifdef S_IXOTH
2312                 *r |= S_IXOTH;
2313 #else /* def S_IXOTH */
2314                 {errno = EINVAL; return -1;}
2315 #endif /* ndef S_IXOTH */
2316         if ((x & Mono_Posix_FilePermissions_S_IXUSR) == Mono_Posix_FilePermissions_S_IXUSR)
2317 #ifdef S_IXUSR
2318                 *r |= S_IXUSR;
2319 #else /* def S_IXUSR */
2320                 {errno = EINVAL; return -1;}
2321 #endif /* ndef S_IXUSR */
2322         if (x == 0)
2323                 return 0;
2324         return 0;
2325 }
2326
2327 int Mono_Posix_ToFilePermissions (unsigned int x, unsigned int *r)
2328 {
2329         *r = 0;
2330         if (x == 0)
2331                 return 0;
2332 #ifdef ACCESSPERMS
2333         if ((x & ACCESSPERMS) == ACCESSPERMS)
2334                 *r |= Mono_Posix_FilePermissions_ACCESSPERMS;
2335 #endif /* ndef ACCESSPERMS */
2336 #ifdef ALLPERMS
2337         if ((x & ALLPERMS) == ALLPERMS)
2338                 *r |= Mono_Posix_FilePermissions_ALLPERMS;
2339 #endif /* ndef ALLPERMS */
2340 #ifdef DEFFILEMODE
2341         if ((x & DEFFILEMODE) == DEFFILEMODE)
2342                 *r |= Mono_Posix_FilePermissions_DEFFILEMODE;
2343 #endif /* ndef DEFFILEMODE */
2344 #ifdef S_IFBLK
2345         if ((x & S_IFBLK) == S_IFBLK)
2346                 *r |= Mono_Posix_FilePermissions_S_IFBLK;
2347 #endif /* ndef S_IFBLK */
2348 #ifdef S_IFCHR
2349         if ((x & S_IFCHR) == S_IFCHR)
2350                 *r |= Mono_Posix_FilePermissions_S_IFCHR;
2351 #endif /* ndef S_IFCHR */
2352 #ifdef S_IFDIR
2353         if ((x & S_IFDIR) == S_IFDIR)
2354                 *r |= Mono_Posix_FilePermissions_S_IFDIR;
2355 #endif /* ndef S_IFDIR */
2356 #ifdef S_IFIFO
2357         if ((x & S_IFIFO) == S_IFIFO)
2358                 *r |= Mono_Posix_FilePermissions_S_IFIFO;
2359 #endif /* ndef S_IFIFO */
2360 #ifdef S_IFLNK
2361         if ((x & S_IFLNK) == S_IFLNK)
2362                 *r |= Mono_Posix_FilePermissions_S_IFLNK;
2363 #endif /* ndef S_IFLNK */
2364 #ifdef S_IFMT
2365         if ((x & S_IFMT) == S_IFMT)
2366                 *r |= Mono_Posix_FilePermissions_S_IFMT;
2367 #endif /* ndef S_IFMT */
2368 #ifdef S_IFREG
2369         if ((x & S_IFREG) == S_IFREG)
2370                 *r |= Mono_Posix_FilePermissions_S_IFREG;
2371 #endif /* ndef S_IFREG */
2372 #ifdef S_IFSOCK
2373         if ((x & S_IFSOCK) == S_IFSOCK)
2374                 *r |= Mono_Posix_FilePermissions_S_IFSOCK;
2375 #endif /* ndef S_IFSOCK */
2376 #ifdef S_IRGRP
2377         if ((x & S_IRGRP) == S_IRGRP)
2378                 *r |= Mono_Posix_FilePermissions_S_IRGRP;
2379 #endif /* ndef S_IRGRP */
2380 #ifdef S_IROTH
2381         if ((x & S_IROTH) == S_IROTH)
2382                 *r |= Mono_Posix_FilePermissions_S_IROTH;
2383 #endif /* ndef S_IROTH */
2384 #ifdef S_IRUSR
2385         if ((x & S_IRUSR) == S_IRUSR)
2386                 *r |= Mono_Posix_FilePermissions_S_IRUSR;
2387 #endif /* ndef S_IRUSR */
2388 #ifdef S_IRWXG
2389         if ((x & S_IRWXG) == S_IRWXG)
2390                 *r |= Mono_Posix_FilePermissions_S_IRWXG;
2391 #endif /* ndef S_IRWXG */
2392 #ifdef S_IRWXO
2393         if ((x & S_IRWXO) == S_IRWXO)
2394                 *r |= Mono_Posix_FilePermissions_S_IRWXO;
2395 #endif /* ndef S_IRWXO */
2396 #ifdef S_IRWXU
2397         if ((x & S_IRWXU) == S_IRWXU)
2398                 *r |= Mono_Posix_FilePermissions_S_IRWXU;
2399 #endif /* ndef S_IRWXU */
2400 #ifdef S_ISGID
2401         if ((x & S_ISGID) == S_ISGID)
2402                 *r |= Mono_Posix_FilePermissions_S_ISGID;
2403 #endif /* ndef S_ISGID */
2404 #ifdef S_ISUID
2405         if ((x & S_ISUID) == S_ISUID)
2406                 *r |= Mono_Posix_FilePermissions_S_ISUID;
2407 #endif /* ndef S_ISUID */
2408 #ifdef S_ISVTX
2409         if ((x & S_ISVTX) == S_ISVTX)
2410                 *r |= Mono_Posix_FilePermissions_S_ISVTX;
2411 #endif /* ndef S_ISVTX */
2412 #ifdef S_IWGRP
2413         if ((x & S_IWGRP) == S_IWGRP)
2414                 *r |= Mono_Posix_FilePermissions_S_IWGRP;
2415 #endif /* ndef S_IWGRP */
2416 #ifdef S_IWOTH
2417         if ((x & S_IWOTH) == S_IWOTH)
2418                 *r |= Mono_Posix_FilePermissions_S_IWOTH;
2419 #endif /* ndef S_IWOTH */
2420 #ifdef S_IWUSR
2421         if ((x & S_IWUSR) == S_IWUSR)
2422                 *r |= Mono_Posix_FilePermissions_S_IWUSR;
2423 #endif /* ndef S_IWUSR */
2424 #ifdef S_IXGRP
2425         if ((x & S_IXGRP) == S_IXGRP)
2426                 *r |= Mono_Posix_FilePermissions_S_IXGRP;
2427 #endif /* ndef S_IXGRP */
2428 #ifdef S_IXOTH
2429         if ((x & S_IXOTH) == S_IXOTH)
2430                 *r |= Mono_Posix_FilePermissions_S_IXOTH;
2431 #endif /* ndef S_IXOTH */
2432 #ifdef S_IXUSR
2433         if ((x & S_IXUSR) == S_IXUSR)
2434                 *r |= Mono_Posix_FilePermissions_S_IXUSR;
2435 #endif /* ndef S_IXUSR */
2436         return 0;
2437 }
2438
2439 int Mono_Posix_FromLockType (short x, short *r)
2440 {
2441         *r = 0;
2442         if (x == Mono_Posix_LockType_F_RDLCK)
2443 #ifdef F_RDLCK
2444                 {*r = F_RDLCK; return 0;}
2445 #else /* def F_RDLCK */
2446                 {errno = EINVAL; return -1;}
2447 #endif /* ndef F_RDLCK */
2448         if (x == Mono_Posix_LockType_F_UNLCK)
2449 #ifdef F_UNLCK
2450                 {*r = F_UNLCK; return 0;}
2451 #else /* def F_UNLCK */
2452                 {errno = EINVAL; return -1;}
2453 #endif /* ndef F_UNLCK */
2454         if (x == Mono_Posix_LockType_F_WRLCK)
2455 #ifdef F_WRLCK
2456                 {*r = F_WRLCK; return 0;}
2457 #else /* def F_WRLCK */
2458                 {errno = EINVAL; return -1;}
2459 #endif /* ndef F_WRLCK */
2460         if (x == 0)
2461                 return 0;
2462         errno = EINVAL; return -1;
2463 }
2464
2465 int Mono_Posix_ToLockType (short x, short *r)
2466 {
2467         *r = 0;
2468         if (x == 0)
2469                 return 0;
2470 #ifdef F_RDLCK
2471         if (x == F_RDLCK)
2472                 {*r = Mono_Posix_LockType_F_RDLCK; return 0;}
2473 #endif /* ndef F_RDLCK */
2474 #ifdef F_UNLCK
2475         if (x == F_UNLCK)
2476                 {*r = Mono_Posix_LockType_F_UNLCK; return 0;}
2477 #endif /* ndef F_UNLCK */
2478 #ifdef F_WRLCK
2479         if (x == F_WRLCK)
2480                 {*r = Mono_Posix_LockType_F_WRLCK; return 0;}
2481 #endif /* ndef F_WRLCK */
2482         errno = EINVAL; return -1;
2483 }
2484
2485 int Mono_Posix_FromLockfCommand (int x, int *r)
2486 {
2487         *r = 0;
2488         if (x == Mono_Posix_LockfCommand_F_LOCK)
2489 #ifdef F_LOCK
2490                 {*r = F_LOCK; return 0;}
2491 #else /* def F_LOCK */
2492                 {errno = EINVAL; return -1;}
2493 #endif /* ndef F_LOCK */
2494         if (x == Mono_Posix_LockfCommand_F_TEST)
2495 #ifdef F_TEST
2496                 {*r = F_TEST; return 0;}
2497 #else /* def F_TEST */
2498                 {errno = EINVAL; return -1;}
2499 #endif /* ndef F_TEST */
2500         if (x == Mono_Posix_LockfCommand_F_TLOCK)
2501 #ifdef F_TLOCK
2502                 {*r = F_TLOCK; return 0;}
2503 #else /* def F_TLOCK */
2504                 {errno = EINVAL; return -1;}
2505 #endif /* ndef F_TLOCK */
2506         if (x == Mono_Posix_LockfCommand_F_ULOCK)
2507 #ifdef F_ULOCK
2508                 {*r = F_ULOCK; return 0;}
2509 #else /* def F_ULOCK */
2510                 {errno = EINVAL; return -1;}
2511 #endif /* ndef F_ULOCK */
2512         if (x == 0)
2513                 return 0;
2514         errno = EINVAL; return -1;
2515 }
2516
2517 int Mono_Posix_ToLockfCommand (int x, int *r)
2518 {
2519         *r = 0;
2520         if (x == 0)
2521                 return 0;
2522 #ifdef F_LOCK
2523         if (x == F_LOCK)
2524                 {*r = Mono_Posix_LockfCommand_F_LOCK; return 0;}
2525 #endif /* ndef F_LOCK */
2526 #ifdef F_TEST
2527         if (x == F_TEST)
2528                 {*r = Mono_Posix_LockfCommand_F_TEST; return 0;}
2529 #endif /* ndef F_TEST */
2530 #ifdef F_TLOCK
2531         if (x == F_TLOCK)
2532                 {*r = Mono_Posix_LockfCommand_F_TLOCK; return 0;}
2533 #endif /* ndef F_TLOCK */
2534 #ifdef F_ULOCK
2535         if (x == F_ULOCK)
2536                 {*r = Mono_Posix_LockfCommand_F_ULOCK; return 0;}
2537 #endif /* ndef F_ULOCK */
2538         errno = EINVAL; return -1;
2539 }
2540
2541 int Mono_Posix_FromMlockallFlags (int x, int *r)
2542 {
2543         *r = 0;
2544         if ((x & Mono_Posix_MlockallFlags_MCL_CURRENT) == Mono_Posix_MlockallFlags_MCL_CURRENT)
2545 #ifdef MCL_CURRENT
2546                 *r |= MCL_CURRENT;
2547 #else /* def MCL_CURRENT */
2548                 {errno = EINVAL; return -1;}
2549 #endif /* ndef MCL_CURRENT */
2550         if ((x & Mono_Posix_MlockallFlags_MCL_FUTURE) == Mono_Posix_MlockallFlags_MCL_FUTURE)
2551 #ifdef MCL_FUTURE
2552                 *r |= MCL_FUTURE;
2553 #else /* def MCL_FUTURE */
2554                 {errno = EINVAL; return -1;}
2555 #endif /* ndef MCL_FUTURE */
2556         if (x == 0)
2557                 return 0;
2558         return 0;
2559 }
2560
2561 int Mono_Posix_ToMlockallFlags (int x, int *r)
2562 {
2563         *r = 0;
2564         if (x == 0)
2565                 return 0;
2566 #ifdef MCL_CURRENT
2567         if ((x & MCL_CURRENT) == MCL_CURRENT)
2568                 *r |= Mono_Posix_MlockallFlags_MCL_CURRENT;
2569 #endif /* ndef MCL_CURRENT */
2570 #ifdef MCL_FUTURE
2571         if ((x & MCL_FUTURE) == MCL_FUTURE)
2572                 *r |= Mono_Posix_MlockallFlags_MCL_FUTURE;
2573 #endif /* ndef MCL_FUTURE */
2574         return 0;
2575 }
2576
2577 int Mono_Posix_FromMmapFlags (int x, int *r)
2578 {
2579         *r = 0;
2580         if ((x & Mono_Posix_MmapFlags_MAP_ANON) == Mono_Posix_MmapFlags_MAP_ANON)
2581 #ifdef MAP_ANON
2582                 *r |= MAP_ANON;
2583 #else /* def MAP_ANON */
2584                 {errno = EINVAL; return -1;}
2585 #endif /* ndef MAP_ANON */
2586         if ((x & Mono_Posix_MmapFlags_MAP_ANONYMOUS) == Mono_Posix_MmapFlags_MAP_ANONYMOUS)
2587 #ifdef MAP_ANONYMOUS
2588                 *r |= MAP_ANONYMOUS;
2589 #else /* def MAP_ANONYMOUS */
2590                 {errno = EINVAL; return -1;}
2591 #endif /* ndef MAP_ANONYMOUS */
2592         if ((x & Mono_Posix_MmapFlags_MAP_DENYWRITE) == Mono_Posix_MmapFlags_MAP_DENYWRITE)
2593 #ifdef MAP_DENYWRITE
2594                 *r |= MAP_DENYWRITE;
2595 #else /* def MAP_DENYWRITE */
2596                 {errno = EINVAL; return -1;}
2597 #endif /* ndef MAP_DENYWRITE */
2598         if ((x & Mono_Posix_MmapFlags_MAP_EXECUTABLE) == Mono_Posix_MmapFlags_MAP_EXECUTABLE)
2599 #ifdef MAP_EXECUTABLE
2600                 *r |= MAP_EXECUTABLE;
2601 #else /* def MAP_EXECUTABLE */
2602                 {errno = EINVAL; return -1;}
2603 #endif /* ndef MAP_EXECUTABLE */
2604         if ((x & Mono_Posix_MmapFlags_MAP_FILE) == Mono_Posix_MmapFlags_MAP_FILE)
2605 #ifdef MAP_FILE
2606                 *r |= MAP_FILE;
2607 #else /* def MAP_FILE */
2608                 {errno = EINVAL; return -1;}
2609 #endif /* ndef MAP_FILE */
2610         if ((x & Mono_Posix_MmapFlags_MAP_FIXED) == Mono_Posix_MmapFlags_MAP_FIXED)
2611 #ifdef MAP_FIXED
2612                 *r |= MAP_FIXED;
2613 #else /* def MAP_FIXED */
2614                 {errno = EINVAL; return -1;}
2615 #endif /* ndef MAP_FIXED */
2616         if ((x & Mono_Posix_MmapFlags_MAP_GROWSDOWN) == Mono_Posix_MmapFlags_MAP_GROWSDOWN)
2617 #ifdef MAP_GROWSDOWN
2618                 *r |= MAP_GROWSDOWN;
2619 #else /* def MAP_GROWSDOWN */
2620                 {errno = EINVAL; return -1;}
2621 #endif /* ndef MAP_GROWSDOWN */
2622         if ((x & Mono_Posix_MmapFlags_MAP_LOCKED) == Mono_Posix_MmapFlags_MAP_LOCKED)
2623 #ifdef MAP_LOCKED
2624                 *r |= MAP_LOCKED;
2625 #else /* def MAP_LOCKED */
2626                 {errno = EINVAL; return -1;}
2627 #endif /* ndef MAP_LOCKED */
2628         if ((x & Mono_Posix_MmapFlags_MAP_NONBLOCK) == Mono_Posix_MmapFlags_MAP_NONBLOCK)
2629 #ifdef MAP_NONBLOCK
2630                 *r |= MAP_NONBLOCK;
2631 #else /* def MAP_NONBLOCK */
2632                 {errno = EINVAL; return -1;}
2633 #endif /* ndef MAP_NONBLOCK */
2634         if ((x & Mono_Posix_MmapFlags_MAP_NORESERVE) == Mono_Posix_MmapFlags_MAP_NORESERVE)
2635 #ifdef MAP_NORESERVE
2636                 *r |= MAP_NORESERVE;
2637 #else /* def MAP_NORESERVE */
2638                 {errno = EINVAL; return -1;}
2639 #endif /* ndef MAP_NORESERVE */
2640         if ((x & Mono_Posix_MmapFlags_MAP_POPULATE) == Mono_Posix_MmapFlags_MAP_POPULATE)
2641 #ifdef MAP_POPULATE
2642                 *r |= MAP_POPULATE;
2643 #else /* def MAP_POPULATE */
2644                 {errno = EINVAL; return -1;}
2645 #endif /* ndef MAP_POPULATE */
2646         if ((x & Mono_Posix_MmapFlags_MAP_PRIVATE) == Mono_Posix_MmapFlags_MAP_PRIVATE)
2647 #ifdef MAP_PRIVATE
2648                 *r |= MAP_PRIVATE;
2649 #else /* def MAP_PRIVATE */
2650                 {errno = EINVAL; return -1;}
2651 #endif /* ndef MAP_PRIVATE */
2652         if ((x & Mono_Posix_MmapFlags_MAP_SHARED) == Mono_Posix_MmapFlags_MAP_SHARED)
2653 #ifdef MAP_SHARED
2654                 *r |= MAP_SHARED;
2655 #else /* def MAP_SHARED */
2656                 {errno = EINVAL; return -1;}
2657 #endif /* ndef MAP_SHARED */
2658         if ((x & Mono_Posix_MmapFlags_MAP_TYPE) == Mono_Posix_MmapFlags_MAP_TYPE)
2659 #ifdef MAP_TYPE
2660                 *r |= MAP_TYPE;
2661 #else /* def MAP_TYPE */
2662                 {errno = EINVAL; return -1;}
2663 #endif /* ndef MAP_TYPE */
2664         if (x == 0)
2665                 return 0;
2666         return 0;
2667 }
2668
2669 int Mono_Posix_ToMmapFlags (int x, int *r)
2670 {
2671         *r = 0;
2672         if (x == 0)
2673                 return 0;
2674 #ifdef MAP_ANON
2675         if ((x & MAP_ANON) == MAP_ANON)
2676                 *r |= Mono_Posix_MmapFlags_MAP_ANON;
2677 #endif /* ndef MAP_ANON */
2678 #ifdef MAP_ANONYMOUS
2679         if ((x & MAP_ANONYMOUS) == MAP_ANONYMOUS)
2680                 *r |= Mono_Posix_MmapFlags_MAP_ANONYMOUS;
2681 #endif /* ndef MAP_ANONYMOUS */
2682 #ifdef MAP_DENYWRITE
2683         if ((x & MAP_DENYWRITE) == MAP_DENYWRITE)
2684                 *r |= Mono_Posix_MmapFlags_MAP_DENYWRITE;
2685 #endif /* ndef MAP_DENYWRITE */
2686 #ifdef MAP_EXECUTABLE
2687         if ((x & MAP_EXECUTABLE) == MAP_EXECUTABLE)
2688                 *r |= Mono_Posix_MmapFlags_MAP_EXECUTABLE;
2689 #endif /* ndef MAP_EXECUTABLE */
2690 #ifdef MAP_FILE
2691         if ((x & MAP_FILE) == MAP_FILE)
2692                 *r |= Mono_Posix_MmapFlags_MAP_FILE;
2693 #endif /* ndef MAP_FILE */
2694 #ifdef MAP_FIXED
2695         if ((x & MAP_FIXED) == MAP_FIXED)
2696                 *r |= Mono_Posix_MmapFlags_MAP_FIXED;
2697 #endif /* ndef MAP_FIXED */
2698 #ifdef MAP_GROWSDOWN
2699         if ((x & MAP_GROWSDOWN) == MAP_GROWSDOWN)
2700                 *r |= Mono_Posix_MmapFlags_MAP_GROWSDOWN;
2701 #endif /* ndef MAP_GROWSDOWN */
2702 #ifdef MAP_LOCKED
2703         if ((x & MAP_LOCKED) == MAP_LOCKED)
2704                 *r |= Mono_Posix_MmapFlags_MAP_LOCKED;
2705 #endif /* ndef MAP_LOCKED */
2706 #ifdef MAP_NONBLOCK
2707         if ((x & MAP_NONBLOCK) == MAP_NONBLOCK)
2708                 *r |= Mono_Posix_MmapFlags_MAP_NONBLOCK;
2709 #endif /* ndef MAP_NONBLOCK */
2710 #ifdef MAP_NORESERVE
2711         if ((x & MAP_NORESERVE) == MAP_NORESERVE)
2712                 *r |= Mono_Posix_MmapFlags_MAP_NORESERVE;
2713 #endif /* ndef MAP_NORESERVE */
2714 #ifdef MAP_POPULATE
2715         if ((x & MAP_POPULATE) == MAP_POPULATE)
2716                 *r |= Mono_Posix_MmapFlags_MAP_POPULATE;
2717 #endif /* ndef MAP_POPULATE */
2718 #ifdef MAP_PRIVATE
2719         if ((x & MAP_PRIVATE) == MAP_PRIVATE)
2720                 *r |= Mono_Posix_MmapFlags_MAP_PRIVATE;
2721 #endif /* ndef MAP_PRIVATE */
2722 #ifdef MAP_SHARED
2723         if ((x & MAP_SHARED) == MAP_SHARED)
2724                 *r |= Mono_Posix_MmapFlags_MAP_SHARED;
2725 #endif /* ndef MAP_SHARED */
2726 #ifdef MAP_TYPE
2727         if ((x & MAP_TYPE) == MAP_TYPE)
2728                 *r |= Mono_Posix_MmapFlags_MAP_TYPE;
2729 #endif /* ndef MAP_TYPE */
2730         return 0;
2731 }
2732
2733 int Mono_Posix_FromMmapProts (int x, int *r)
2734 {
2735         *r = 0;
2736         if ((x & Mono_Posix_MmapProts_PROT_EXEC) == Mono_Posix_MmapProts_PROT_EXEC)
2737 #ifdef PROT_EXEC
2738                 *r |= PROT_EXEC;
2739 #else /* def PROT_EXEC */
2740                 {errno = EINVAL; return -1;}
2741 #endif /* ndef PROT_EXEC */
2742         if ((x & Mono_Posix_MmapProts_PROT_GROWSDOWN) == Mono_Posix_MmapProts_PROT_GROWSDOWN)
2743 #ifdef PROT_GROWSDOWN
2744                 *r |= PROT_GROWSDOWN;
2745 #else /* def PROT_GROWSDOWN */
2746                 {errno = EINVAL; return -1;}
2747 #endif /* ndef PROT_GROWSDOWN */
2748         if ((x & Mono_Posix_MmapProts_PROT_GROWSUP) == Mono_Posix_MmapProts_PROT_GROWSUP)
2749 #ifdef PROT_GROWSUP
2750                 *r |= PROT_GROWSUP;
2751 #else /* def PROT_GROWSUP */
2752                 {errno = EINVAL; return -1;}
2753 #endif /* ndef PROT_GROWSUP */
2754         if ((x & Mono_Posix_MmapProts_PROT_NONE) == Mono_Posix_MmapProts_PROT_NONE)
2755 #ifdef PROT_NONE
2756                 *r |= PROT_NONE;
2757 #else /* def PROT_NONE */
2758                 {errno = EINVAL; return -1;}
2759 #endif /* ndef PROT_NONE */
2760         if ((x & Mono_Posix_MmapProts_PROT_READ) == Mono_Posix_MmapProts_PROT_READ)
2761 #ifdef PROT_READ
2762                 *r |= PROT_READ;
2763 #else /* def PROT_READ */
2764                 {errno = EINVAL; return -1;}
2765 #endif /* ndef PROT_READ */
2766         if ((x & Mono_Posix_MmapProts_PROT_WRITE) == Mono_Posix_MmapProts_PROT_WRITE)
2767 #ifdef PROT_WRITE
2768                 *r |= PROT_WRITE;
2769 #else /* def PROT_WRITE */
2770                 {errno = EINVAL; return -1;}
2771 #endif /* ndef PROT_WRITE */
2772         if (x == 0)
2773                 return 0;
2774         return 0;
2775 }
2776
2777 int Mono_Posix_ToMmapProts (int x, int *r)
2778 {
2779         *r = 0;
2780         if (x == 0)
2781                 return 0;
2782 #ifdef PROT_EXEC
2783         if ((x & PROT_EXEC) == PROT_EXEC)
2784                 *r |= Mono_Posix_MmapProts_PROT_EXEC;
2785 #endif /* ndef PROT_EXEC */
2786 #ifdef PROT_GROWSDOWN
2787         if ((x & PROT_GROWSDOWN) == PROT_GROWSDOWN)
2788                 *r |= Mono_Posix_MmapProts_PROT_GROWSDOWN;
2789 #endif /* ndef PROT_GROWSDOWN */
2790 #ifdef PROT_GROWSUP
2791         if ((x & PROT_GROWSUP) == PROT_GROWSUP)
2792                 *r |= Mono_Posix_MmapProts_PROT_GROWSUP;
2793 #endif /* ndef PROT_GROWSUP */
2794 #ifdef PROT_NONE
2795         if ((x & PROT_NONE) == PROT_NONE)
2796                 *r |= Mono_Posix_MmapProts_PROT_NONE;
2797 #endif /* ndef PROT_NONE */
2798 #ifdef PROT_READ
2799         if ((x & PROT_READ) == PROT_READ)
2800                 *r |= Mono_Posix_MmapProts_PROT_READ;
2801 #endif /* ndef PROT_READ */
2802 #ifdef PROT_WRITE
2803         if ((x & PROT_WRITE) == PROT_WRITE)
2804                 *r |= Mono_Posix_MmapProts_PROT_WRITE;
2805 #endif /* ndef PROT_WRITE */
2806         return 0;
2807 }
2808
2809 int Mono_Posix_FromMountFlags (guint64 x, guint64 *r)
2810 {
2811         *r = 0;
2812         if ((x & Mono_Posix_MountFlags_ST_APPEND) == Mono_Posix_MountFlags_ST_APPEND)
2813 #ifdef ST_APPEND
2814                 *r |= ST_APPEND;
2815 #else /* def ST_APPEND */
2816                 {errno = EINVAL; return -1;}
2817 #endif /* ndef ST_APPEND */
2818         if ((x & Mono_Posix_MountFlags_ST_IMMUTABLE) == Mono_Posix_MountFlags_ST_IMMUTABLE)
2819 #ifdef ST_IMMUTABLE
2820                 *r |= ST_IMMUTABLE;
2821 #else /* def ST_IMMUTABLE */
2822                 {errno = EINVAL; return -1;}
2823 #endif /* ndef ST_IMMUTABLE */
2824         if ((x & Mono_Posix_MountFlags_ST_MANDLOCK) == Mono_Posix_MountFlags_ST_MANDLOCK)
2825 #ifdef ST_MANDLOCK
2826                 *r |= ST_MANDLOCK;
2827 #else /* def ST_MANDLOCK */
2828                 {errno = EINVAL; return -1;}
2829 #endif /* ndef ST_MANDLOCK */
2830         if ((x & Mono_Posix_MountFlags_ST_NOATIME) == Mono_Posix_MountFlags_ST_NOATIME)
2831 #ifdef ST_NOATIME
2832                 *r |= ST_NOATIME;
2833 #else /* def ST_NOATIME */
2834                 {errno = EINVAL; return -1;}
2835 #endif /* ndef ST_NOATIME */
2836         if ((x & Mono_Posix_MountFlags_ST_NODEV) == Mono_Posix_MountFlags_ST_NODEV)
2837 #ifdef ST_NODEV
2838                 *r |= ST_NODEV;
2839 #else /* def ST_NODEV */
2840                 {errno = EINVAL; return -1;}
2841 #endif /* ndef ST_NODEV */
2842         if ((x & Mono_Posix_MountFlags_ST_NODIRATIME) == Mono_Posix_MountFlags_ST_NODIRATIME)
2843 #ifdef ST_NODIRATIME
2844                 *r |= ST_NODIRATIME;
2845 #else /* def ST_NODIRATIME */
2846                 {errno = EINVAL; return -1;}
2847 #endif /* ndef ST_NODIRATIME */
2848         if ((x & Mono_Posix_MountFlags_ST_NOSUID) == Mono_Posix_MountFlags_ST_NOSUID)
2849 #ifdef ST_NOSUID
2850                 *r |= ST_NOSUID;
2851 #else /* def ST_NOSUID */
2852                 {errno = EINVAL; return -1;}
2853 #endif /* ndef ST_NOSUID */
2854         if ((x & Mono_Posix_MountFlags_ST_RDONLY) == Mono_Posix_MountFlags_ST_RDONLY)
2855 #ifdef ST_RDONLY
2856                 *r |= ST_RDONLY;
2857 #else /* def ST_RDONLY */
2858                 {errno = EINVAL; return -1;}
2859 #endif /* ndef ST_RDONLY */
2860         if ((x & Mono_Posix_MountFlags_ST_SYNCHRONOUS) == Mono_Posix_MountFlags_ST_SYNCHRONOUS)
2861 #ifdef ST_SYNCHRONOUS
2862                 *r |= ST_SYNCHRONOUS;
2863 #else /* def ST_SYNCHRONOUS */
2864                 {errno = EINVAL; return -1;}
2865 #endif /* ndef ST_SYNCHRONOUS */
2866         if ((x & Mono_Posix_MountFlags_ST_WRITE) == Mono_Posix_MountFlags_ST_WRITE)
2867 #ifdef ST_WRITE
2868                 *r |= ST_WRITE;
2869 #else /* def ST_WRITE */
2870                 {errno = EINVAL; return -1;}
2871 #endif /* ndef ST_WRITE */
2872         if (x == 0)
2873                 return 0;
2874         return 0;
2875 }
2876
2877 int Mono_Posix_ToMountFlags (guint64 x, guint64 *r)
2878 {
2879         *r = 0;
2880         if (x == 0)
2881                 return 0;
2882 #ifdef ST_APPEND
2883         if ((x & ST_APPEND) == ST_APPEND)
2884                 *r |= Mono_Posix_MountFlags_ST_APPEND;
2885 #endif /* ndef ST_APPEND */
2886 #ifdef ST_IMMUTABLE
2887         if ((x & ST_IMMUTABLE) == ST_IMMUTABLE)
2888                 *r |= Mono_Posix_MountFlags_ST_IMMUTABLE;
2889 #endif /* ndef ST_IMMUTABLE */
2890 #ifdef ST_MANDLOCK
2891         if ((x & ST_MANDLOCK) == ST_MANDLOCK)
2892                 *r |= Mono_Posix_MountFlags_ST_MANDLOCK;
2893 #endif /* ndef ST_MANDLOCK */
2894 #ifdef ST_NOATIME
2895         if ((x & ST_NOATIME) == ST_NOATIME)
2896                 *r |= Mono_Posix_MountFlags_ST_NOATIME;
2897 #endif /* ndef ST_NOATIME */
2898 #ifdef ST_NODEV
2899         if ((x & ST_NODEV) == ST_NODEV)
2900                 *r |= Mono_Posix_MountFlags_ST_NODEV;
2901 #endif /* ndef ST_NODEV */
2902 #ifdef ST_NODIRATIME
2903         if ((x & ST_NODIRATIME) == ST_NODIRATIME)
2904                 *r |= Mono_Posix_MountFlags_ST_NODIRATIME;
2905 #endif /* ndef ST_NODIRATIME */
2906 #ifdef ST_NOSUID
2907         if ((x & ST_NOSUID) == ST_NOSUID)
2908                 *r |= Mono_Posix_MountFlags_ST_NOSUID;
2909 #endif /* ndef ST_NOSUID */
2910 #ifdef ST_RDONLY
2911         if ((x & ST_RDONLY) == ST_RDONLY)
2912                 *r |= Mono_Posix_MountFlags_ST_RDONLY;
2913 #endif /* ndef ST_RDONLY */
2914 #ifdef ST_SYNCHRONOUS
2915         if ((x & ST_SYNCHRONOUS) == ST_SYNCHRONOUS)
2916                 *r |= Mono_Posix_MountFlags_ST_SYNCHRONOUS;
2917 #endif /* ndef ST_SYNCHRONOUS */
2918 #ifdef ST_WRITE
2919         if ((x & ST_WRITE) == ST_WRITE)
2920                 *r |= Mono_Posix_MountFlags_ST_WRITE;
2921 #endif /* ndef ST_WRITE */
2922         return 0;
2923 }
2924
2925 int Mono_Posix_FromMremapFlags (guint64 x, guint64 *r)
2926 {
2927         *r = 0;
2928         if ((x & Mono_Posix_MremapFlags_MREMAP_MAYMOVE) == Mono_Posix_MremapFlags_MREMAP_MAYMOVE)
2929 #ifdef MREMAP_MAYMOVE
2930                 *r |= MREMAP_MAYMOVE;
2931 #else /* def MREMAP_MAYMOVE */
2932                 {errno = EINVAL; return -1;}
2933 #endif /* ndef MREMAP_MAYMOVE */
2934         if (x == 0)
2935                 return 0;
2936         return 0;
2937 }
2938
2939 int Mono_Posix_ToMremapFlags (guint64 x, guint64 *r)
2940 {
2941         *r = 0;
2942         if (x == 0)
2943                 return 0;
2944 #ifdef MREMAP_MAYMOVE
2945         if ((x & MREMAP_MAYMOVE) == MREMAP_MAYMOVE)
2946                 *r |= Mono_Posix_MremapFlags_MREMAP_MAYMOVE;
2947 #endif /* ndef MREMAP_MAYMOVE */
2948         return 0;
2949 }
2950
2951 int Mono_Posix_FromMsyncFlags (int x, int *r)
2952 {
2953         *r = 0;
2954         if ((x & Mono_Posix_MsyncFlags_MS_ASYNC) == Mono_Posix_MsyncFlags_MS_ASYNC)
2955 #ifdef MS_ASYNC
2956                 *r |= MS_ASYNC;
2957 #else /* def MS_ASYNC */
2958                 {errno = EINVAL; return -1;}
2959 #endif /* ndef MS_ASYNC */
2960         if ((x & Mono_Posix_MsyncFlags_MS_INVALIDATE) == Mono_Posix_MsyncFlags_MS_INVALIDATE)
2961 #ifdef MS_INVALIDATE
2962                 *r |= MS_INVALIDATE;
2963 #else /* def MS_INVALIDATE */
2964                 {errno = EINVAL; return -1;}
2965 #endif /* ndef MS_INVALIDATE */
2966         if ((x & Mono_Posix_MsyncFlags_MS_SYNC) == Mono_Posix_MsyncFlags_MS_SYNC)
2967 #ifdef MS_SYNC
2968                 *r |= MS_SYNC;
2969 #else /* def MS_SYNC */
2970                 {errno = EINVAL; return -1;}
2971 #endif /* ndef MS_SYNC */
2972         if (x == 0)
2973                 return 0;
2974         return 0;
2975 }
2976
2977 int Mono_Posix_ToMsyncFlags (int x, int *r)
2978 {
2979         *r = 0;
2980         if (x == 0)
2981                 return 0;
2982 #ifdef MS_ASYNC
2983         if ((x & MS_ASYNC) == MS_ASYNC)
2984                 *r |= Mono_Posix_MsyncFlags_MS_ASYNC;
2985 #endif /* ndef MS_ASYNC */
2986 #ifdef MS_INVALIDATE
2987         if ((x & MS_INVALIDATE) == MS_INVALIDATE)
2988                 *r |= Mono_Posix_MsyncFlags_MS_INVALIDATE;
2989 #endif /* ndef MS_INVALIDATE */
2990 #ifdef MS_SYNC
2991         if ((x & MS_SYNC) == MS_SYNC)
2992                 *r |= Mono_Posix_MsyncFlags_MS_SYNC;
2993 #endif /* ndef MS_SYNC */
2994         return 0;
2995 }
2996
2997 int Mono_Posix_FromOpenFlags (int x, int *r)
2998 {
2999         *r = 0;
3000         if ((x & Mono_Posix_OpenFlags_O_APPEND) == Mono_Posix_OpenFlags_O_APPEND)
3001 #ifdef O_APPEND
3002                 *r |= O_APPEND;
3003 #else /* def O_APPEND */
3004                 {errno = EINVAL; return -1;}
3005 #endif /* ndef O_APPEND */
3006         if ((x & Mono_Posix_OpenFlags_O_ASYNC) == Mono_Posix_OpenFlags_O_ASYNC)
3007 #ifdef O_ASYNC
3008                 *r |= O_ASYNC;
3009 #else /* def O_ASYNC */
3010                 {errno = EINVAL; return -1;}
3011 #endif /* ndef O_ASYNC */
3012         if ((x & Mono_Posix_OpenFlags_O_CREAT) == Mono_Posix_OpenFlags_O_CREAT)
3013 #ifdef O_CREAT
3014                 *r |= O_CREAT;
3015 #else /* def O_CREAT */
3016                 {errno = EINVAL; return -1;}
3017 #endif /* ndef O_CREAT */
3018         if ((x & Mono_Posix_OpenFlags_O_DIRECT) == Mono_Posix_OpenFlags_O_DIRECT)
3019 #ifdef O_DIRECT
3020                 *r |= O_DIRECT;
3021 #else /* def O_DIRECT */
3022                 {errno = EINVAL; return -1;}
3023 #endif /* ndef O_DIRECT */
3024         if ((x & Mono_Posix_OpenFlags_O_DIRECTORY) == Mono_Posix_OpenFlags_O_DIRECTORY)
3025 #ifdef O_DIRECTORY
3026                 *r |= O_DIRECTORY;
3027 #else /* def O_DIRECTORY */
3028                 {errno = EINVAL; return -1;}
3029 #endif /* ndef O_DIRECTORY */
3030         if ((x & Mono_Posix_OpenFlags_O_EXCL) == Mono_Posix_OpenFlags_O_EXCL)
3031 #ifdef O_EXCL
3032                 *r |= O_EXCL;
3033 #else /* def O_EXCL */
3034                 {errno = EINVAL; return -1;}
3035 #endif /* ndef O_EXCL */
3036         if ((x & Mono_Posix_OpenFlags_O_LARGEFILE) == Mono_Posix_OpenFlags_O_LARGEFILE)
3037 #ifdef O_LARGEFILE
3038                 *r |= O_LARGEFILE;
3039 #else /* def O_LARGEFILE */
3040                 {errno = EINVAL; return -1;}
3041 #endif /* ndef O_LARGEFILE */
3042         if ((x & Mono_Posix_OpenFlags_O_NOCTTY) == Mono_Posix_OpenFlags_O_NOCTTY)
3043 #ifdef O_NOCTTY
3044                 *r |= O_NOCTTY;
3045 #else /* def O_NOCTTY */
3046                 {errno = EINVAL; return -1;}
3047 #endif /* ndef O_NOCTTY */
3048         if ((x & Mono_Posix_OpenFlags_O_NOFOLLOW) == Mono_Posix_OpenFlags_O_NOFOLLOW)
3049 #ifdef O_NOFOLLOW
3050                 *r |= O_NOFOLLOW;
3051 #else /* def O_NOFOLLOW */
3052                 {errno = EINVAL; return -1;}
3053 #endif /* ndef O_NOFOLLOW */
3054         if ((x & Mono_Posix_OpenFlags_O_NONBLOCK) == Mono_Posix_OpenFlags_O_NONBLOCK)
3055 #ifdef O_NONBLOCK
3056                 *r |= O_NONBLOCK;
3057 #else /* def O_NONBLOCK */
3058                 {errno = EINVAL; return -1;}
3059 #endif /* ndef O_NONBLOCK */
3060         if ((x & Mono_Posix_OpenFlags_O_RDONLY) == Mono_Posix_OpenFlags_O_RDONLY)
3061 #ifdef O_RDONLY
3062                 *r |= O_RDONLY;
3063 #else /* def O_RDONLY */
3064                 {errno = EINVAL; return -1;}
3065 #endif /* ndef O_RDONLY */
3066         if ((x & Mono_Posix_OpenFlags_O_RDWR) == Mono_Posix_OpenFlags_O_RDWR)
3067 #ifdef O_RDWR
3068                 *r |= O_RDWR;
3069 #else /* def O_RDWR */
3070                 {errno = EINVAL; return -1;}
3071 #endif /* ndef O_RDWR */
3072         if ((x & Mono_Posix_OpenFlags_O_SYNC) == Mono_Posix_OpenFlags_O_SYNC)
3073 #ifdef O_SYNC
3074                 *r |= O_SYNC;
3075 #else /* def O_SYNC */
3076                 {errno = EINVAL; return -1;}
3077 #endif /* ndef O_SYNC */
3078         if ((x & Mono_Posix_OpenFlags_O_TRUNC) == Mono_Posix_OpenFlags_O_TRUNC)
3079 #ifdef O_TRUNC
3080                 *r |= O_TRUNC;
3081 #else /* def O_TRUNC */
3082                 {errno = EINVAL; return -1;}
3083 #endif /* ndef O_TRUNC */
3084         if ((x & Mono_Posix_OpenFlags_O_WRONLY) == Mono_Posix_OpenFlags_O_WRONLY)
3085 #ifdef O_WRONLY
3086                 *r |= O_WRONLY;
3087 #else /* def O_WRONLY */
3088                 {errno = EINVAL; return -1;}
3089 #endif /* ndef O_WRONLY */
3090         if (x == 0)
3091                 return 0;
3092         return 0;
3093 }
3094
3095 int Mono_Posix_ToOpenFlags (int x, int *r)
3096 {
3097         *r = 0;
3098         if (x == 0)
3099                 return 0;
3100 #ifdef O_APPEND
3101         if ((x & O_APPEND) == O_APPEND)
3102                 *r |= Mono_Posix_OpenFlags_O_APPEND;
3103 #endif /* ndef O_APPEND */
3104 #ifdef O_ASYNC
3105         if ((x & O_ASYNC) == O_ASYNC)
3106                 *r |= Mono_Posix_OpenFlags_O_ASYNC;
3107 #endif /* ndef O_ASYNC */
3108 #ifdef O_CREAT
3109         if ((x & O_CREAT) == O_CREAT)
3110                 *r |= Mono_Posix_OpenFlags_O_CREAT;
3111 #endif /* ndef O_CREAT */
3112 #ifdef O_DIRECT
3113         if ((x & O_DIRECT) == O_DIRECT)
3114                 *r |= Mono_Posix_OpenFlags_O_DIRECT;
3115 #endif /* ndef O_DIRECT */
3116 #ifdef O_DIRECTORY
3117         if ((x & O_DIRECTORY) == O_DIRECTORY)
3118                 *r |= Mono_Posix_OpenFlags_O_DIRECTORY;
3119 #endif /* ndef O_DIRECTORY */
3120 #ifdef O_EXCL
3121         if ((x & O_EXCL) == O_EXCL)
3122                 *r |= Mono_Posix_OpenFlags_O_EXCL;
3123 #endif /* ndef O_EXCL */
3124 #ifdef O_LARGEFILE
3125         if ((x & O_LARGEFILE) == O_LARGEFILE)
3126                 *r |= Mono_Posix_OpenFlags_O_LARGEFILE;
3127 #endif /* ndef O_LARGEFILE */
3128 #ifdef O_NOCTTY
3129         if ((x & O_NOCTTY) == O_NOCTTY)
3130                 *r |= Mono_Posix_OpenFlags_O_NOCTTY;
3131 #endif /* ndef O_NOCTTY */
3132 #ifdef O_NOFOLLOW
3133         if ((x & O_NOFOLLOW) == O_NOFOLLOW)
3134                 *r |= Mono_Posix_OpenFlags_O_NOFOLLOW;
3135 #endif /* ndef O_NOFOLLOW */
3136 #ifdef O_NONBLOCK
3137         if ((x & O_NONBLOCK) == O_NONBLOCK)
3138                 *r |= Mono_Posix_OpenFlags_O_NONBLOCK;
3139 #endif /* ndef O_NONBLOCK */
3140 #ifdef O_RDONLY
3141         if ((x & O_RDONLY) == O_RDONLY)
3142                 *r |= Mono_Posix_OpenFlags_O_RDONLY;
3143 #endif /* ndef O_RDONLY */
3144 #ifdef O_RDWR
3145         if ((x & O_RDWR) == O_RDWR)
3146                 *r |= Mono_Posix_OpenFlags_O_RDWR;
3147 #endif /* ndef O_RDWR */
3148 #ifdef O_SYNC
3149         if ((x & O_SYNC) == O_SYNC)
3150                 *r |= Mono_Posix_OpenFlags_O_SYNC;
3151 #endif /* ndef O_SYNC */
3152 #ifdef O_TRUNC
3153         if ((x & O_TRUNC) == O_TRUNC)
3154                 *r |= Mono_Posix_OpenFlags_O_TRUNC;
3155 #endif /* ndef O_TRUNC */
3156 #ifdef O_WRONLY
3157         if ((x & O_WRONLY) == O_WRONLY)
3158                 *r |= Mono_Posix_OpenFlags_O_WRONLY;
3159 #endif /* ndef O_WRONLY */
3160         return 0;
3161 }
3162
3163 int Mono_Posix_FromPathconfName (int x, int *r)
3164 {
3165         *r = 0;
3166         if (x == Mono_Posix_PathconfName__PC_2_SYMLINKS)
3167 #ifdef _PC_2_SYMLINKS
3168                 {*r = _PC_2_SYMLINKS; return 0;}
3169 #else /* def _PC_2_SYMLINKS */
3170                 {errno = EINVAL; return -1;}
3171 #endif /* ndef _PC_2_SYMLINKS */
3172         if (x == Mono_Posix_PathconfName__PC_ALLOC_SIZE_MIN)
3173 #ifdef _PC_ALLOC_SIZE_MIN
3174                 {*r = _PC_ALLOC_SIZE_MIN; return 0;}
3175 #else /* def _PC_ALLOC_SIZE_MIN */
3176                 {errno = EINVAL; return -1;}
3177 #endif /* ndef _PC_ALLOC_SIZE_MIN */
3178         if (x == Mono_Posix_PathconfName__PC_ASYNC_IO)
3179 #ifdef _PC_ASYNC_IO
3180                 {*r = _PC_ASYNC_IO; return 0;}
3181 #else /* def _PC_ASYNC_IO */
3182                 {errno = EINVAL; return -1;}
3183 #endif /* ndef _PC_ASYNC_IO */
3184         if (x == Mono_Posix_PathconfName__PC_CHOWN_RESTRICTED)
3185 #ifdef _PC_CHOWN_RESTRICTED
3186                 {*r = _PC_CHOWN_RESTRICTED; return 0;}
3187 #else /* def _PC_CHOWN_RESTRICTED */
3188                 {errno = EINVAL; return -1;}
3189 #endif /* ndef _PC_CHOWN_RESTRICTED */
3190         if (x == Mono_Posix_PathconfName__PC_FILESIZEBITS)
3191 #ifdef _PC_FILESIZEBITS
3192                 {*r = _PC_FILESIZEBITS; return 0;}
3193 #else /* def _PC_FILESIZEBITS */
3194                 {errno = EINVAL; return -1;}
3195 #endif /* ndef _PC_FILESIZEBITS */
3196         if (x == Mono_Posix_PathconfName__PC_LINK_MAX)
3197 #ifdef _PC_LINK_MAX
3198                 {*r = _PC_LINK_MAX; return 0;}
3199 #else /* def _PC_LINK_MAX */
3200                 {errno = EINVAL; return -1;}
3201 #endif /* ndef _PC_LINK_MAX */
3202         if (x == Mono_Posix_PathconfName__PC_MAX_CANON)
3203 #ifdef _PC_MAX_CANON
3204                 {*r = _PC_MAX_CANON; return 0;}
3205 #else /* def _PC_MAX_CANON */
3206                 {errno = EINVAL; return -1;}
3207 #endif /* ndef _PC_MAX_CANON */
3208         if (x == Mono_Posix_PathconfName__PC_MAX_INPUT)
3209 #ifdef _PC_MAX_INPUT
3210                 {*r = _PC_MAX_INPUT; return 0;}
3211 #else /* def _PC_MAX_INPUT */
3212                 {errno = EINVAL; return -1;}
3213 #endif /* ndef _PC_MAX_INPUT */
3214         if (x == Mono_Posix_PathconfName__PC_NAME_MAX)
3215 #ifdef _PC_NAME_MAX
3216                 {*r = _PC_NAME_MAX; return 0;}
3217 #else /* def _PC_NAME_MAX */
3218                 {errno = EINVAL; return -1;}
3219 #endif /* ndef _PC_NAME_MAX */
3220         if (x == Mono_Posix_PathconfName__PC_NO_TRUNC)
3221 #ifdef _PC_NO_TRUNC
3222                 {*r = _PC_NO_TRUNC; return 0;}
3223 #else /* def _PC_NO_TRUNC */
3224                 {errno = EINVAL; return -1;}
3225 #endif /* ndef _PC_NO_TRUNC */
3226         if (x == Mono_Posix_PathconfName__PC_PATH_MAX)
3227 #ifdef _PC_PATH_MAX
3228                 {*r = _PC_PATH_MAX; return 0;}
3229 #else /* def _PC_PATH_MAX */
3230                 {errno = EINVAL; return -1;}
3231 #endif /* ndef _PC_PATH_MAX */
3232         if (x == Mono_Posix_PathconfName__PC_PIPE_BUF)
3233 #ifdef _PC_PIPE_BUF
3234                 {*r = _PC_PIPE_BUF; return 0;}
3235 #else /* def _PC_PIPE_BUF */
3236                 {errno = EINVAL; return -1;}
3237 #endif /* ndef _PC_PIPE_BUF */
3238         if (x == Mono_Posix_PathconfName__PC_PRIO_IO)
3239 #ifdef _PC_PRIO_IO
3240                 {*r = _PC_PRIO_IO; return 0;}
3241 #else /* def _PC_PRIO_IO */
3242                 {errno = EINVAL; return -1;}
3243 #endif /* ndef _PC_PRIO_IO */
3244         if (x == Mono_Posix_PathconfName__PC_REC_INCR_XFER_SIZE)
3245 #ifdef _PC_REC_INCR_XFER_SIZE
3246                 {*r = _PC_REC_INCR_XFER_SIZE; return 0;}
3247 #else /* def _PC_REC_INCR_XFER_SIZE */
3248                 {errno = EINVAL; return -1;}
3249 #endif /* ndef _PC_REC_INCR_XFER_SIZE */
3250         if (x == Mono_Posix_PathconfName__PC_REC_MAX_XFER_SIZE)
3251 #ifdef _PC_REC_MAX_XFER_SIZE
3252                 {*r = _PC_REC_MAX_XFER_SIZE; return 0;}
3253 #else /* def _PC_REC_MAX_XFER_SIZE */
3254                 {errno = EINVAL; return -1;}
3255 #endif /* ndef _PC_REC_MAX_XFER_SIZE */
3256         if (x == Mono_Posix_PathconfName__PC_REC_MIN_XFER_SIZE)
3257 #ifdef _PC_REC_MIN_XFER_SIZE
3258                 {*r = _PC_REC_MIN_XFER_SIZE; return 0;}
3259 #else /* def _PC_REC_MIN_XFER_SIZE */
3260                 {errno = EINVAL; return -1;}
3261 #endif /* ndef _PC_REC_MIN_XFER_SIZE */
3262         if (x == Mono_Posix_PathconfName__PC_REC_XFER_ALIGN)
3263 #ifdef _PC_REC_XFER_ALIGN
3264                 {*r = _PC_REC_XFER_ALIGN; return 0;}
3265 #else /* def _PC_REC_XFER_ALIGN */
3266                 {errno = EINVAL; return -1;}
3267 #endif /* ndef _PC_REC_XFER_ALIGN */
3268         if (x == Mono_Posix_PathconfName__PC_SOCK_MAXBUF)
3269 #ifdef _PC_SOCK_MAXBUF
3270                 {*r = _PC_SOCK_MAXBUF; return 0;}
3271 #else /* def _PC_SOCK_MAXBUF */
3272                 {errno = EINVAL; return -1;}
3273 #endif /* ndef _PC_SOCK_MAXBUF */
3274         if (x == Mono_Posix_PathconfName__PC_SYMLINK_MAX)
3275 #ifdef _PC_SYMLINK_MAX
3276                 {*r = _PC_SYMLINK_MAX; return 0;}
3277 #else /* def _PC_SYMLINK_MAX */
3278                 {errno = EINVAL; return -1;}
3279 #endif /* ndef _PC_SYMLINK_MAX */
3280         if (x == Mono_Posix_PathconfName__PC_SYNC_IO)
3281 #ifdef _PC_SYNC_IO
3282                 {*r = _PC_SYNC_IO; return 0;}
3283 #else /* def _PC_SYNC_IO */
3284                 {errno = EINVAL; return -1;}
3285 #endif /* ndef _PC_SYNC_IO */
3286         if (x == Mono_Posix_PathconfName__PC_VDISABLE)
3287 #ifdef _PC_VDISABLE
3288                 {*r = _PC_VDISABLE; return 0;}
3289 #else /* def _PC_VDISABLE */
3290                 {errno = EINVAL; return -1;}
3291 #endif /* ndef _PC_VDISABLE */
3292         if (x == 0)
3293                 return 0;
3294         errno = EINVAL; return -1;
3295 }
3296
3297 int Mono_Posix_ToPathconfName (int x, int *r)
3298 {
3299         *r = 0;
3300         if (x == 0)
3301                 return 0;
3302 #ifdef _PC_2_SYMLINKS
3303         if (x == _PC_2_SYMLINKS)
3304                 {*r = Mono_Posix_PathconfName__PC_2_SYMLINKS; return 0;}
3305 #endif /* ndef _PC_2_SYMLINKS */
3306 #ifdef _PC_ALLOC_SIZE_MIN
3307         if (x == _PC_ALLOC_SIZE_MIN)
3308                 {*r = Mono_Posix_PathconfName__PC_ALLOC_SIZE_MIN; return 0;}
3309 #endif /* ndef _PC_ALLOC_SIZE_MIN */
3310 #ifdef _PC_ASYNC_IO
3311         if (x == _PC_ASYNC_IO)
3312                 {*r = Mono_Posix_PathconfName__PC_ASYNC_IO; return 0;}
3313 #endif /* ndef _PC_ASYNC_IO */
3314 #ifdef _PC_CHOWN_RESTRICTED
3315         if (x == _PC_CHOWN_RESTRICTED)
3316                 {*r = Mono_Posix_PathconfName__PC_CHOWN_RESTRICTED; return 0;}
3317 #endif /* ndef _PC_CHOWN_RESTRICTED */
3318 #ifdef _PC_FILESIZEBITS
3319         if (x == _PC_FILESIZEBITS)
3320                 {*r = Mono_Posix_PathconfName__PC_FILESIZEBITS; return 0;}
3321 #endif /* ndef _PC_FILESIZEBITS */
3322 #ifdef _PC_LINK_MAX
3323         if (x == _PC_LINK_MAX)
3324                 {*r = Mono_Posix_PathconfName__PC_LINK_MAX; return 0;}
3325 #endif /* ndef _PC_LINK_MAX */
3326 #ifdef _PC_MAX_CANON
3327         if (x == _PC_MAX_CANON)
3328                 {*r = Mono_Posix_PathconfName__PC_MAX_CANON; return 0;}
3329 #endif /* ndef _PC_MAX_CANON */
3330 #ifdef _PC_MAX_INPUT
3331         if (x == _PC_MAX_INPUT)
3332                 {*r = Mono_Posix_PathconfName__PC_MAX_INPUT; return 0;}
3333 #endif /* ndef _PC_MAX_INPUT */
3334 #ifdef _PC_NAME_MAX
3335         if (x == _PC_NAME_MAX)
3336                 {*r = Mono_Posix_PathconfName__PC_NAME_MAX; return 0;}
3337 #endif /* ndef _PC_NAME_MAX */
3338 #ifdef _PC_NO_TRUNC
3339         if (x == _PC_NO_TRUNC)
3340                 {*r = Mono_Posix_PathconfName__PC_NO_TRUNC; return 0;}
3341 #endif /* ndef _PC_NO_TRUNC */
3342 #ifdef _PC_PATH_MAX
3343         if (x == _PC_PATH_MAX)
3344                 {*r = Mono_Posix_PathconfName__PC_PATH_MAX; return 0;}
3345 #endif /* ndef _PC_PATH_MAX */
3346 #ifdef _PC_PIPE_BUF
3347         if (x == _PC_PIPE_BUF)
3348                 {*r = Mono_Posix_PathconfName__PC_PIPE_BUF; return 0;}
3349 #endif /* ndef _PC_PIPE_BUF */
3350 #ifdef _PC_PRIO_IO
3351         if (x == _PC_PRIO_IO)
3352                 {*r = Mono_Posix_PathconfName__PC_PRIO_IO; return 0;}
3353 #endif /* ndef _PC_PRIO_IO */
3354 #ifdef _PC_REC_INCR_XFER_SIZE
3355         if (x == _PC_REC_INCR_XFER_SIZE)
3356                 {*r = Mono_Posix_PathconfName__PC_REC_INCR_XFER_SIZE; return 0;}
3357 #endif /* ndef _PC_REC_INCR_XFER_SIZE */
3358 #ifdef _PC_REC_MAX_XFER_SIZE
3359         if (x == _PC_REC_MAX_XFER_SIZE)
3360                 {*r = Mono_Posix_PathconfName__PC_REC_MAX_XFER_SIZE; return 0;}
3361 #endif /* ndef _PC_REC_MAX_XFER_SIZE */
3362 #ifdef _PC_REC_MIN_XFER_SIZE
3363         if (x == _PC_REC_MIN_XFER_SIZE)
3364                 {*r = Mono_Posix_PathconfName__PC_REC_MIN_XFER_SIZE; return 0;}
3365 #endif /* ndef _PC_REC_MIN_XFER_SIZE */
3366 #ifdef _PC_REC_XFER_ALIGN
3367         if (x == _PC_REC_XFER_ALIGN)
3368                 {*r = Mono_Posix_PathconfName__PC_REC_XFER_ALIGN; return 0;}
3369 #endif /* ndef _PC_REC_XFER_ALIGN */
3370 #ifdef _PC_SOCK_MAXBUF
3371         if (x == _PC_SOCK_MAXBUF)
3372                 {*r = Mono_Posix_PathconfName__PC_SOCK_MAXBUF; return 0;}
3373 #endif /* ndef _PC_SOCK_MAXBUF */
3374 #ifdef _PC_SYMLINK_MAX
3375         if (x == _PC_SYMLINK_MAX)
3376                 {*r = Mono_Posix_PathconfName__PC_SYMLINK_MAX; return 0;}
3377 #endif /* ndef _PC_SYMLINK_MAX */
3378 #ifdef _PC_SYNC_IO
3379         if (x == _PC_SYNC_IO)
3380                 {*r = Mono_Posix_PathconfName__PC_SYNC_IO; return 0;}
3381 #endif /* ndef _PC_SYNC_IO */
3382 #ifdef _PC_VDISABLE
3383         if (x == _PC_VDISABLE)
3384                 {*r = Mono_Posix_PathconfName__PC_VDISABLE; return 0;}
3385 #endif /* ndef _PC_VDISABLE */
3386         errno = EINVAL; return -1;
3387 }
3388
3389 int Mono_Posix_FromPollEvents (short x, short *r)
3390 {
3391         *r = 0;
3392         if ((x & Mono_Posix_PollEvents_POLLERR) == Mono_Posix_PollEvents_POLLERR)
3393 #ifdef POLLERR
3394                 *r |= POLLERR;
3395 #else /* def POLLERR */
3396                 {errno = EINVAL; return -1;}
3397 #endif /* ndef POLLERR */
3398         if ((x & Mono_Posix_PollEvents_POLLHUP) == Mono_Posix_PollEvents_POLLHUP)
3399 #ifdef POLLHUP
3400                 *r |= POLLHUP;
3401 #else /* def POLLHUP */
3402                 {errno = EINVAL; return -1;}
3403 #endif /* ndef POLLHUP */
3404         if ((x & Mono_Posix_PollEvents_POLLIN) == Mono_Posix_PollEvents_POLLIN)
3405 #ifdef POLLIN
3406                 *r |= POLLIN;
3407 #else /* def POLLIN */
3408                 {errno = EINVAL; return -1;}
3409 #endif /* ndef POLLIN */
3410         if ((x & Mono_Posix_PollEvents_POLLNVAL) == Mono_Posix_PollEvents_POLLNVAL)
3411 #ifdef POLLNVAL
3412                 *r |= POLLNVAL;
3413 #else /* def POLLNVAL */
3414                 {errno = EINVAL; return -1;}
3415 #endif /* ndef POLLNVAL */
3416         if ((x & Mono_Posix_PollEvents_POLLOUT) == Mono_Posix_PollEvents_POLLOUT)
3417 #ifdef POLLOUT
3418                 *r |= POLLOUT;
3419 #else /* def POLLOUT */
3420                 {errno = EINVAL; return -1;}
3421 #endif /* ndef POLLOUT */
3422         if ((x & Mono_Posix_PollEvents_POLLPRI) == Mono_Posix_PollEvents_POLLPRI)
3423 #ifdef POLLPRI
3424                 *r |= POLLPRI;
3425 #else /* def POLLPRI */
3426                 {errno = EINVAL; return -1;}
3427 #endif /* ndef POLLPRI */
3428         if ((x & Mono_Posix_PollEvents_POLLRDBAND) == Mono_Posix_PollEvents_POLLRDBAND)
3429 #ifdef POLLRDBAND
3430                 *r |= POLLRDBAND;
3431 #else /* def POLLRDBAND */
3432                 {errno = EINVAL; return -1;}
3433 #endif /* ndef POLLRDBAND */
3434         if ((x & Mono_Posix_PollEvents_POLLRDNORM) == Mono_Posix_PollEvents_POLLRDNORM)
3435 #ifdef POLLRDNORM
3436                 *r |= POLLRDNORM;
3437 #else /* def POLLRDNORM */
3438                 {errno = EINVAL; return -1;}
3439 #endif /* ndef POLLRDNORM */
3440         if ((x & Mono_Posix_PollEvents_POLLWRBAND) == Mono_Posix_PollEvents_POLLWRBAND)
3441 #ifdef POLLWRBAND
3442                 *r |= POLLWRBAND;
3443 #else /* def POLLWRBAND */
3444                 {errno = EINVAL; return -1;}
3445 #endif /* ndef POLLWRBAND */
3446         if ((x & Mono_Posix_PollEvents_POLLWRNORM) == Mono_Posix_PollEvents_POLLWRNORM)
3447 #ifdef POLLWRNORM
3448                 *r |= POLLWRNORM;
3449 #else /* def POLLWRNORM */
3450                 {errno = EINVAL; return -1;}
3451 #endif /* ndef POLLWRNORM */
3452         if (x == 0)
3453                 return 0;
3454         return 0;
3455 }
3456
3457 int Mono_Posix_ToPollEvents (short x, short *r)
3458 {
3459         *r = 0;
3460         if (x == 0)
3461                 return 0;
3462 #ifdef POLLERR
3463         if ((x & POLLERR) == POLLERR)
3464                 *r |= Mono_Posix_PollEvents_POLLERR;
3465 #endif /* ndef POLLERR */
3466 #ifdef POLLHUP
3467         if ((x & POLLHUP) == POLLHUP)
3468                 *r |= Mono_Posix_PollEvents_POLLHUP;
3469 #endif /* ndef POLLHUP */
3470 #ifdef POLLIN
3471         if ((x & POLLIN) == POLLIN)
3472                 *r |= Mono_Posix_PollEvents_POLLIN;
3473 #endif /* ndef POLLIN */
3474 #ifdef POLLNVAL
3475         if ((x & POLLNVAL) == POLLNVAL)
3476                 *r |= Mono_Posix_PollEvents_POLLNVAL;
3477 #endif /* ndef POLLNVAL */
3478 #ifdef POLLOUT
3479         if ((x & POLLOUT) == POLLOUT)
3480                 *r |= Mono_Posix_PollEvents_POLLOUT;
3481 #endif /* ndef POLLOUT */
3482 #ifdef POLLPRI
3483         if ((x & POLLPRI) == POLLPRI)
3484                 *r |= Mono_Posix_PollEvents_POLLPRI;
3485 #endif /* ndef POLLPRI */
3486 #ifdef POLLRDBAND
3487         if ((x & POLLRDBAND) == POLLRDBAND)
3488                 *r |= Mono_Posix_PollEvents_POLLRDBAND;
3489 #endif /* ndef POLLRDBAND */
3490 #ifdef POLLRDNORM
3491         if ((x & POLLRDNORM) == POLLRDNORM)
3492                 *r |= Mono_Posix_PollEvents_POLLRDNORM;
3493 #endif /* ndef POLLRDNORM */
3494 #ifdef POLLWRBAND
3495         if ((x & POLLWRBAND) == POLLWRBAND)
3496                 *r |= Mono_Posix_PollEvents_POLLWRBAND;
3497 #endif /* ndef POLLWRBAND */
3498 #ifdef POLLWRNORM
3499         if ((x & POLLWRNORM) == POLLWRNORM)
3500                 *r |= Mono_Posix_PollEvents_POLLWRNORM;
3501 #endif /* ndef POLLWRNORM */
3502         return 0;
3503 }
3504
3505 int
3506 Mono_Posix_FromPollfd (struct Mono_Posix_Pollfd *from, struct pollfd *to)
3507 {
3508         _cnm_return_val_if_overflow (int, from->fd, -1);
3509
3510         memset (to, 0, sizeof(*to));
3511
3512         to->fd      = from->fd;
3513         if (Mono_Posix_FromPollEvents (from->events, &to->events) != 0) {
3514                 return -1;
3515         }
3516         if (Mono_Posix_FromPollEvents (from->revents, &to->revents) != 0) {
3517                 return -1;
3518         }
3519
3520         return 0;
3521 }
3522
3523
3524 int
3525 Mono_Posix_ToPollfd (struct pollfd *from, struct Mono_Posix_Pollfd *to)
3526 {
3527         _cnm_return_val_if_overflow (int, from->fd, -1);
3528
3529         memset (to, 0, sizeof(*to));
3530
3531         to->fd      = from->fd;
3532         if (Mono_Posix_ToPollEvents (from->events, &to->events) != 0) {
3533                 return -1;
3534         }
3535         if (Mono_Posix_ToPollEvents (from->revents, &to->revents) != 0) {
3536                 return -1;
3537         }
3538
3539         return 0;
3540 }
3541
3542
3543 int Mono_Posix_FromPosixFadviseAdvice (int x, int *r)
3544 {
3545         *r = 0;
3546         if (x == Mono_Posix_PosixFadviseAdvice_POSIX_FADV_DONTNEED)
3547 #ifdef POSIX_FADV_DONTNEED
3548                 {*r = POSIX_FADV_DONTNEED; return 0;}
3549 #else /* def POSIX_FADV_DONTNEED */
3550                 {errno = EINVAL; return -1;}
3551 #endif /* ndef POSIX_FADV_DONTNEED */
3552         if (x == Mono_Posix_PosixFadviseAdvice_POSIX_FADV_NOREUSE)
3553 #ifdef POSIX_FADV_NOREUSE
3554                 {*r = POSIX_FADV_NOREUSE; return 0;}
3555 #else /* def POSIX_FADV_NOREUSE */
3556                 {errno = EINVAL; return -1;}
3557 #endif /* ndef POSIX_FADV_NOREUSE */
3558         if (x == Mono_Posix_PosixFadviseAdvice_POSIX_FADV_NORMAL)
3559 #ifdef POSIX_FADV_NORMAL
3560                 {*r = POSIX_FADV_NORMAL; return 0;}
3561 #else /* def POSIX_FADV_NORMAL */
3562                 {errno = EINVAL; return -1;}
3563 #endif /* ndef POSIX_FADV_NORMAL */
3564         if (x == Mono_Posix_PosixFadviseAdvice_POSIX_FADV_RANDOM)
3565 #ifdef POSIX_FADV_RANDOM
3566                 {*r = POSIX_FADV_RANDOM; return 0;}
3567 #else /* def POSIX_FADV_RANDOM */
3568                 {errno = EINVAL; return -1;}
3569 #endif /* ndef POSIX_FADV_RANDOM */
3570         if (x == Mono_Posix_PosixFadviseAdvice_POSIX_FADV_SEQUENTIAL)
3571 #ifdef POSIX_FADV_SEQUENTIAL
3572                 {*r = POSIX_FADV_SEQUENTIAL; return 0;}
3573 #else /* def POSIX_FADV_SEQUENTIAL */
3574                 {errno = EINVAL; return -1;}
3575 #endif /* ndef POSIX_FADV_SEQUENTIAL */
3576         if (x == Mono_Posix_PosixFadviseAdvice_POSIX_FADV_WILLNEED)
3577 #ifdef POSIX_FADV_WILLNEED
3578                 {*r = POSIX_FADV_WILLNEED; return 0;}
3579 #else /* def POSIX_FADV_WILLNEED */
3580                 {errno = EINVAL; return -1;}
3581 #endif /* ndef POSIX_FADV_WILLNEED */
3582         if (x == 0)
3583                 return 0;
3584         errno = EINVAL; return -1;
3585 }
3586
3587 int Mono_Posix_ToPosixFadviseAdvice (int x, int *r)
3588 {
3589         *r = 0;
3590         if (x == 0)
3591                 return 0;
3592 #ifdef POSIX_FADV_DONTNEED
3593         if (x == POSIX_FADV_DONTNEED)
3594                 {*r = Mono_Posix_PosixFadviseAdvice_POSIX_FADV_DONTNEED; return 0;}
3595 #endif /* ndef POSIX_FADV_DONTNEED */
3596 #ifdef POSIX_FADV_NOREUSE
3597         if (x == POSIX_FADV_NOREUSE)
3598                 {*r = Mono_Posix_PosixFadviseAdvice_POSIX_FADV_NOREUSE; return 0;}
3599 #endif /* ndef POSIX_FADV_NOREUSE */
3600 #ifdef POSIX_FADV_NORMAL
3601         if (x == POSIX_FADV_NORMAL)
3602                 {*r = Mono_Posix_PosixFadviseAdvice_POSIX_FADV_NORMAL; return 0;}
3603 #endif /* ndef POSIX_FADV_NORMAL */
3604 #ifdef POSIX_FADV_RANDOM
3605         if (x == POSIX_FADV_RANDOM)
3606                 {*r = Mono_Posix_PosixFadviseAdvice_POSIX_FADV_RANDOM; return 0;}
3607 #endif /* ndef POSIX_FADV_RANDOM */
3608 #ifdef POSIX_FADV_SEQUENTIAL
3609         if (x == POSIX_FADV_SEQUENTIAL)
3610                 {*r = Mono_Posix_PosixFadviseAdvice_POSIX_FADV_SEQUENTIAL; return 0;}
3611 #endif /* ndef POSIX_FADV_SEQUENTIAL */
3612 #ifdef POSIX_FADV_WILLNEED
3613         if (x == POSIX_FADV_WILLNEED)
3614                 {*r = Mono_Posix_PosixFadviseAdvice_POSIX_FADV_WILLNEED; return 0;}
3615 #endif /* ndef POSIX_FADV_WILLNEED */
3616         errno = EINVAL; return -1;
3617 }
3618
3619 int Mono_Posix_FromPosixMadviseAdvice (int x, int *r)
3620 {
3621         *r = 0;
3622         if (x == Mono_Posix_PosixMadviseAdvice_POSIX_MADV_DONTNEED)
3623 #ifdef POSIX_MADV_DONTNEED
3624                 {*r = POSIX_MADV_DONTNEED; return 0;}
3625 #else /* def POSIX_MADV_DONTNEED */
3626                 {errno = EINVAL; return -1;}
3627 #endif /* ndef POSIX_MADV_DONTNEED */
3628         if (x == Mono_Posix_PosixMadviseAdvice_POSIX_MADV_NORMAL)
3629 #ifdef POSIX_MADV_NORMAL
3630                 {*r = POSIX_MADV_NORMAL; return 0;}
3631 #else /* def POSIX_MADV_NORMAL */
3632                 {errno = EINVAL; return -1;}
3633 #endif /* ndef POSIX_MADV_NORMAL */
3634         if (x == Mono_Posix_PosixMadviseAdvice_POSIX_MADV_RANDOM)
3635 #ifdef POSIX_MADV_RANDOM
3636                 {*r = POSIX_MADV_RANDOM; return 0;}
3637 #else /* def POSIX_MADV_RANDOM */
3638                 {errno = EINVAL; return -1;}
3639 #endif /* ndef POSIX_MADV_RANDOM */
3640         if (x == Mono_Posix_PosixMadviseAdvice_POSIX_MADV_SEQUENTIAL)
3641 #ifdef POSIX_MADV_SEQUENTIAL
3642                 {*r = POSIX_MADV_SEQUENTIAL; return 0;}
3643 #else /* def POSIX_MADV_SEQUENTIAL */
3644                 {errno = EINVAL; return -1;}
3645 #endif /* ndef POSIX_MADV_SEQUENTIAL */
3646         if (x == Mono_Posix_PosixMadviseAdvice_POSIX_MADV_WILLNEED)
3647 #ifdef POSIX_MADV_WILLNEED
3648                 {*r = POSIX_MADV_WILLNEED; return 0;}
3649 #else /* def POSIX_MADV_WILLNEED */
3650                 {errno = EINVAL; return -1;}
3651 #endif /* ndef POSIX_MADV_WILLNEED */
3652         if (x == 0)
3653                 return 0;
3654         errno = EINVAL; return -1;
3655 }
3656
3657 int Mono_Posix_ToPosixMadviseAdvice (int x, int *r)
3658 {
3659         *r = 0;
3660         if (x == 0)
3661                 return 0;
3662 #ifdef POSIX_MADV_DONTNEED
3663         if (x == POSIX_MADV_DONTNEED)
3664                 {*r = Mono_Posix_PosixMadviseAdvice_POSIX_MADV_DONTNEED; return 0;}
3665 #endif /* ndef POSIX_MADV_DONTNEED */
3666 #ifdef POSIX_MADV_NORMAL
3667         if (x == POSIX_MADV_NORMAL)
3668                 {*r = Mono_Posix_PosixMadviseAdvice_POSIX_MADV_NORMAL; return 0;}
3669 #endif /* ndef POSIX_MADV_NORMAL */
3670 #ifdef POSIX_MADV_RANDOM
3671         if (x == POSIX_MADV_RANDOM)
3672                 {*r = Mono_Posix_PosixMadviseAdvice_POSIX_MADV_RANDOM; return 0;}
3673 #endif /* ndef POSIX_MADV_RANDOM */
3674 #ifdef POSIX_MADV_SEQUENTIAL
3675         if (x == POSIX_MADV_SEQUENTIAL)
3676                 {*r = Mono_Posix_PosixMadviseAdvice_POSIX_MADV_SEQUENTIAL; return 0;}
3677 #endif /* ndef POSIX_MADV_SEQUENTIAL */
3678 #ifdef POSIX_MADV_WILLNEED
3679         if (x == POSIX_MADV_WILLNEED)
3680                 {*r = Mono_Posix_PosixMadviseAdvice_POSIX_MADV_WILLNEED; return 0;}
3681 #endif /* ndef POSIX_MADV_WILLNEED */
3682         errno = EINVAL; return -1;
3683 }
3684
3685 int Mono_Posix_FromSeekFlags (short x, short *r)
3686 {
3687         *r = 0;
3688         if (x == Mono_Posix_SeekFlags_L_INCR)
3689 #ifdef L_INCR
3690                 {*r = L_INCR; return 0;}
3691 #else /* def L_INCR */
3692                 {errno = EINVAL; return -1;}
3693 #endif /* ndef L_INCR */
3694         if (x == Mono_Posix_SeekFlags_L_SET)
3695 #ifdef L_SET
3696                 {*r = L_SET; return 0;}
3697 #else /* def L_SET */
3698                 {errno = EINVAL; return -1;}
3699 #endif /* ndef L_SET */
3700         if (x == Mono_Posix_SeekFlags_L_XTND)
3701 #ifdef L_XTND
3702                 {*r = L_XTND; return 0;}
3703 #else /* def L_XTND */
3704                 {errno = EINVAL; return -1;}
3705 #endif /* ndef L_XTND */
3706         if (x == Mono_Posix_SeekFlags_SEEK_CUR)
3707 #ifdef SEEK_CUR
3708                 {*r = SEEK_CUR; return 0;}
3709 #else /* def SEEK_CUR */
3710                 {errno = EINVAL; return -1;}
3711 #endif /* ndef SEEK_CUR */
3712         if (x == Mono_Posix_SeekFlags_SEEK_END)
3713 #ifdef SEEK_END
3714                 {*r = SEEK_END; return 0;}
3715 #else /* def SEEK_END */
3716                 {errno = EINVAL; return -1;}
3717 #endif /* ndef SEEK_END */
3718         if (x == Mono_Posix_SeekFlags_SEEK_SET)
3719 #ifdef SEEK_SET
3720                 {*r = SEEK_SET; return 0;}
3721 #else /* def SEEK_SET */
3722                 {errno = EINVAL; return -1;}
3723 #endif /* ndef SEEK_SET */
3724         if (x == 0)
3725                 return 0;
3726         errno = EINVAL; return -1;
3727 }
3728
3729 int Mono_Posix_ToSeekFlags (short x, short *r)
3730 {
3731         *r = 0;
3732         if (x == 0)
3733                 return 0;
3734 #ifdef L_INCR
3735         if (x == L_INCR)
3736                 {*r = Mono_Posix_SeekFlags_L_INCR; return 0;}
3737 #endif /* ndef L_INCR */
3738 #ifdef L_SET
3739         if (x == L_SET)
3740                 {*r = Mono_Posix_SeekFlags_L_SET; return 0;}
3741 #endif /* ndef L_SET */
3742 #ifdef L_XTND
3743         if (x == L_XTND)
3744                 {*r = Mono_Posix_SeekFlags_L_XTND; return 0;}
3745 #endif /* ndef L_XTND */
3746 #ifdef SEEK_CUR
3747         if (x == SEEK_CUR)
3748                 {*r = Mono_Posix_SeekFlags_SEEK_CUR; return 0;}
3749 #endif /* ndef SEEK_CUR */
3750 #ifdef SEEK_END
3751         if (x == SEEK_END)
3752                 {*r = Mono_Posix_SeekFlags_SEEK_END; return 0;}
3753 #endif /* ndef SEEK_END */
3754 #ifdef SEEK_SET
3755         if (x == SEEK_SET)
3756                 {*r = Mono_Posix_SeekFlags_SEEK_SET; return 0;}
3757 #endif /* ndef SEEK_SET */
3758         errno = EINVAL; return -1;
3759 }
3760
3761 int Mono_Posix_FromSignum (int x, int *r)
3762 {
3763         *r = 0;
3764         if (x == Mono_Posix_Signum_SIGABRT)
3765 #ifdef SIGABRT
3766                 {*r = SIGABRT; return 0;}
3767 #else /* def SIGABRT */
3768                 {errno = EINVAL; return -1;}
3769 #endif /* ndef SIGABRT */
3770         if (x == Mono_Posix_Signum_SIGALRM)
3771 #ifdef SIGALRM
3772                 {*r = SIGALRM; return 0;}
3773 #else /* def SIGALRM */
3774                 {errno = EINVAL; return -1;}
3775 #endif /* ndef SIGALRM */
3776         if (x == Mono_Posix_Signum_SIGBUS)
3777 #ifdef SIGBUS
3778                 {*r = SIGBUS; return 0;}
3779 #else /* def SIGBUS */
3780                 {errno = EINVAL; return -1;}
3781 #endif /* ndef SIGBUS */
3782         if (x == Mono_Posix_Signum_SIGCHLD)
3783 #ifdef SIGCHLD
3784                 {*r = SIGCHLD; return 0;}
3785 #else /* def SIGCHLD */
3786                 {errno = EINVAL; return -1;}
3787 #endif /* ndef SIGCHLD */
3788         if (x == Mono_Posix_Signum_SIGCLD)
3789 #ifdef SIGCLD
3790                 {*r = SIGCLD; return 0;}
3791 #else /* def SIGCLD */
3792                 {errno = EINVAL; return -1;}
3793 #endif /* ndef SIGCLD */
3794         if (x == Mono_Posix_Signum_SIGCONT)
3795 #ifdef SIGCONT
3796                 {*r = SIGCONT; return 0;}
3797 #else /* def SIGCONT */
3798                 {errno = EINVAL; return -1;}
3799 #endif /* ndef SIGCONT */
3800         if (x == Mono_Posix_Signum_SIGFPE)
3801 #ifdef SIGFPE
3802                 {*r = SIGFPE; return 0;}
3803 #else /* def SIGFPE */
3804                 {errno = EINVAL; return -1;}
3805 #endif /* ndef SIGFPE */
3806         if (x == Mono_Posix_Signum_SIGHUP)
3807 #ifdef SIGHUP
3808                 {*r = SIGHUP; return 0;}
3809 #else /* def SIGHUP */
3810                 {errno = EINVAL; return -1;}
3811 #endif /* ndef SIGHUP */
3812         if (x == Mono_Posix_Signum_SIGILL)
3813 #ifdef SIGILL
3814                 {*r = SIGILL; return 0;}
3815 #else /* def SIGILL */
3816                 {errno = EINVAL; return -1;}
3817 #endif /* ndef SIGILL */
3818         if (x == Mono_Posix_Signum_SIGINT)
3819 #ifdef SIGINT
3820                 {*r = SIGINT; return 0;}
3821 #else /* def SIGINT */
3822                 {errno = EINVAL; return -1;}
3823 #endif /* ndef SIGINT */
3824         if (x == Mono_Posix_Signum_SIGIO)
3825 #ifdef SIGIO
3826                 {*r = SIGIO; return 0;}
3827 #else /* def SIGIO */
3828                 {errno = EINVAL; return -1;}
3829 #endif /* ndef SIGIO */
3830         if (x == Mono_Posix_Signum_SIGIOT)
3831 #ifdef SIGIOT
3832                 {*r = SIGIOT; return 0;}
3833 #else /* def SIGIOT */
3834                 {errno = EINVAL; return -1;}
3835 #endif /* ndef SIGIOT */
3836         if (x == Mono_Posix_Signum_SIGKILL)
3837 #ifdef SIGKILL
3838                 {*r = SIGKILL; return 0;}
3839 #else /* def SIGKILL */
3840                 {errno = EINVAL; return -1;}
3841 #endif /* ndef SIGKILL */
3842         if (x == Mono_Posix_Signum_SIGPIPE)
3843 #ifdef SIGPIPE
3844                 {*r = SIGPIPE; return 0;}
3845 #else /* def SIGPIPE */
3846                 {errno = EINVAL; return -1;}
3847 #endif /* ndef SIGPIPE */
3848         if (x == Mono_Posix_Signum_SIGPOLL)
3849 #ifdef SIGPOLL
3850                 {*r = SIGPOLL; return 0;}
3851 #else /* def SIGPOLL */
3852                 {errno = EINVAL; return -1;}
3853 #endif /* ndef SIGPOLL */
3854         if (x == Mono_Posix_Signum_SIGPROF)
3855 #ifdef SIGPROF
3856                 {*r = SIGPROF; return 0;}
3857 #else /* def SIGPROF */
3858                 {errno = EINVAL; return -1;}
3859 #endif /* ndef SIGPROF */
3860         if (x == Mono_Posix_Signum_SIGPWR)
3861 #ifdef SIGPWR
3862                 {*r = SIGPWR; return 0;}
3863 #else /* def SIGPWR */
3864                 {errno = EINVAL; return -1;}
3865 #endif /* ndef SIGPWR */
3866         if (x == Mono_Posix_Signum_SIGQUIT)
3867 #ifdef SIGQUIT
3868                 {*r = SIGQUIT; return 0;}
3869 #else /* def SIGQUIT */
3870                 {errno = EINVAL; return -1;}
3871 #endif /* ndef SIGQUIT */
3872         if (x == Mono_Posix_Signum_SIGSEGV)
3873 #ifdef SIGSEGV
3874                 {*r = SIGSEGV; return 0;}
3875 #else /* def SIGSEGV */
3876                 {errno = EINVAL; return -1;}
3877 #endif /* ndef SIGSEGV */
3878         if (x == Mono_Posix_Signum_SIGSTKFLT)
3879 #ifdef SIGSTKFLT
3880                 {*r = SIGSTKFLT; return 0;}
3881 #else /* def SIGSTKFLT */
3882                 {errno = EINVAL; return -1;}
3883 #endif /* ndef SIGSTKFLT */
3884         if (x == Mono_Posix_Signum_SIGSTOP)
3885 #ifdef SIGSTOP
3886                 {*r = SIGSTOP; return 0;}
3887 #else /* def SIGSTOP */
3888                 {errno = EINVAL; return -1;}
3889 #endif /* ndef SIGSTOP */
3890         if (x == Mono_Posix_Signum_SIGSYS)
3891 #ifdef SIGSYS
3892                 {*r = SIGSYS; return 0;}
3893 #else /* def SIGSYS */
3894                 {errno = EINVAL; return -1;}
3895 #endif /* ndef SIGSYS */
3896         if (x == Mono_Posix_Signum_SIGTERM)
3897 #ifdef SIGTERM
3898                 {*r = SIGTERM; return 0;}
3899 #else /* def SIGTERM */
3900                 {errno = EINVAL; return -1;}
3901 #endif /* ndef SIGTERM */
3902         if (x == Mono_Posix_Signum_SIGTRAP)
3903 #ifdef SIGTRAP
3904                 {*r = SIGTRAP; return 0;}
3905 #else /* def SIGTRAP */
3906                 {errno = EINVAL; return -1;}
3907 #endif /* ndef SIGTRAP */
3908         if (x == Mono_Posix_Signum_SIGTSTP)
3909 #ifdef SIGTSTP
3910                 {*r = SIGTSTP; return 0;}
3911 #else /* def SIGTSTP */
3912                 {errno = EINVAL; return -1;}
3913 #endif /* ndef SIGTSTP */
3914         if (x == Mono_Posix_Signum_SIGTTIN)
3915 #ifdef SIGTTIN
3916                 {*r = SIGTTIN; return 0;}
3917 #else /* def SIGTTIN */
3918                 {errno = EINVAL; return -1;}
3919 #endif /* ndef SIGTTIN */
3920         if (x == Mono_Posix_Signum_SIGTTOU)
3921 #ifdef SIGTTOU
3922                 {*r = SIGTTOU; return 0;}
3923 #else /* def SIGTTOU */
3924                 {errno = EINVAL; return -1;}
3925 #endif /* ndef SIGTTOU */
3926         if (x == Mono_Posix_Signum_SIGUNUSED)
3927 #ifdef SIGUNUSED
3928                 {*r = SIGUNUSED; return 0;}
3929 #else /* def SIGUNUSED */
3930                 {errno = EINVAL; return -1;}
3931 #endif /* ndef SIGUNUSED */
3932         if (x == Mono_Posix_Signum_SIGURG)
3933 #ifdef SIGURG
3934                 {*r = SIGURG; return 0;}
3935 #else /* def SIGURG */
3936                 {errno = EINVAL; return -1;}
3937 #endif /* ndef SIGURG */
3938         if (x == Mono_Posix_Signum_SIGUSR1)
3939 #ifdef SIGUSR1
3940                 {*r = SIGUSR1; return 0;}
3941 #else /* def SIGUSR1 */
3942                 {errno = EINVAL; return -1;}
3943 #endif /* ndef SIGUSR1 */
3944         if (x == Mono_Posix_Signum_SIGUSR2)
3945 #ifdef SIGUSR2
3946                 {*r = SIGUSR2; return 0;}
3947 #else /* def SIGUSR2 */
3948                 {errno = EINVAL; return -1;}
3949 #endif /* ndef SIGUSR2 */
3950         if (x == Mono_Posix_Signum_SIGVTALRM)
3951 #ifdef SIGVTALRM
3952                 {*r = SIGVTALRM; return 0;}
3953 #else /* def SIGVTALRM */
3954                 {errno = EINVAL; return -1;}
3955 #endif /* ndef SIGVTALRM */
3956         if (x == Mono_Posix_Signum_SIGWINCH)
3957 #ifdef SIGWINCH
3958                 {*r = SIGWINCH; return 0;}
3959 #else /* def SIGWINCH */
3960                 {errno = EINVAL; return -1;}
3961 #endif /* ndef SIGWINCH */
3962         if (x == Mono_Posix_Signum_SIGXCPU)
3963 #ifdef SIGXCPU
3964                 {*r = SIGXCPU; return 0;}
3965 #else /* def SIGXCPU */
3966                 {errno = EINVAL; return -1;}
3967 #endif /* ndef SIGXCPU */
3968         if (x == Mono_Posix_Signum_SIGXFSZ)
3969 #ifdef SIGXFSZ
3970                 {*r = SIGXFSZ; return 0;}
3971 #else /* def SIGXFSZ */
3972                 {errno = EINVAL; return -1;}
3973 #endif /* ndef SIGXFSZ */
3974         if (x == 0)
3975                 return 0;
3976         errno = EINVAL; return -1;
3977 }
3978
3979 int Mono_Posix_ToSignum (int x, int *r)
3980 {
3981         *r = 0;
3982         if (x == 0)
3983                 return 0;
3984 #ifdef SIGABRT
3985         if (x == SIGABRT)
3986                 {*r = Mono_Posix_Signum_SIGABRT; return 0;}
3987 #endif /* ndef SIGABRT */
3988 #ifdef SIGALRM
3989         if (x == SIGALRM)
3990                 {*r = Mono_Posix_Signum_SIGALRM; return 0;}
3991 #endif /* ndef SIGALRM */
3992 #ifdef SIGBUS
3993         if (x == SIGBUS)
3994                 {*r = Mono_Posix_Signum_SIGBUS; return 0;}
3995 #endif /* ndef SIGBUS */
3996 #ifdef SIGCHLD
3997         if (x == SIGCHLD)
3998                 {*r = Mono_Posix_Signum_SIGCHLD; return 0;}
3999 #endif /* ndef SIGCHLD */
4000 #ifdef SIGCLD
4001         if (x == SIGCLD)
4002                 {*r = Mono_Posix_Signum_SIGCLD; return 0;}
4003 #endif /* ndef SIGCLD */
4004 #ifdef SIGCONT
4005         if (x == SIGCONT)
4006                 {*r = Mono_Posix_Signum_SIGCONT; return 0;}
4007 #endif /* ndef SIGCONT */
4008 #ifdef SIGFPE
4009         if (x == SIGFPE)
4010                 {*r = Mono_Posix_Signum_SIGFPE; return 0;}
4011 #endif /* ndef SIGFPE */
4012 #ifdef SIGHUP
4013         if (x == SIGHUP)
4014                 {*r = Mono_Posix_Signum_SIGHUP; return 0;}
4015 #endif /* ndef SIGHUP */
4016 #ifdef SIGILL
4017         if (x == SIGILL)
4018                 {*r = Mono_Posix_Signum_SIGILL; return 0;}
4019 #endif /* ndef SIGILL */
4020 #ifdef SIGINT
4021         if (x == SIGINT)
4022                 {*r = Mono_Posix_Signum_SIGINT; return 0;}
4023 #endif /* ndef SIGINT */
4024 #ifdef SIGIO
4025         if (x == SIGIO)
4026                 {*r = Mono_Posix_Signum_SIGIO; return 0;}
4027 #endif /* ndef SIGIO */
4028 #ifdef SIGIOT
4029         if (x == SIGIOT)
4030                 {*r = Mono_Posix_Signum_SIGIOT; return 0;}
4031 #endif /* ndef SIGIOT */
4032 #ifdef SIGKILL
4033         if (x == SIGKILL)
4034                 {*r = Mono_Posix_Signum_SIGKILL; return 0;}
4035 #endif /* ndef SIGKILL */
4036 #ifdef SIGPIPE
4037         if (x == SIGPIPE)
4038                 {*r = Mono_Posix_Signum_SIGPIPE; return 0;}
4039 #endif /* ndef SIGPIPE */
4040 #ifdef SIGPOLL
4041         if (x == SIGPOLL)
4042                 {*r = Mono_Posix_Signum_SIGPOLL; return 0;}
4043 #endif /* ndef SIGPOLL */
4044 #ifdef SIGPROF
4045         if (x == SIGPROF)
4046                 {*r = Mono_Posix_Signum_SIGPROF; return 0;}
4047 #endif /* ndef SIGPROF */
4048 #ifdef SIGPWR
4049         if (x == SIGPWR)
4050                 {*r = Mono_Posix_Signum_SIGPWR; return 0;}
4051 #endif /* ndef SIGPWR */
4052 #ifdef SIGQUIT
4053         if (x == SIGQUIT)
4054                 {*r = Mono_Posix_Signum_SIGQUIT; return 0;}
4055 #endif /* ndef SIGQUIT */
4056 #ifdef SIGSEGV
4057         if (x == SIGSEGV)
4058                 {*r = Mono_Posix_Signum_SIGSEGV; return 0;}
4059 #endif /* ndef SIGSEGV */
4060 #ifdef SIGSTKFLT
4061         if (x == SIGSTKFLT)
4062                 {*r = Mono_Posix_Signum_SIGSTKFLT; return 0;}
4063 #endif /* ndef SIGSTKFLT */
4064 #ifdef SIGSTOP
4065         if (x == SIGSTOP)
4066                 {*r = Mono_Posix_Signum_SIGSTOP; return 0;}
4067 #endif /* ndef SIGSTOP */
4068 #ifdef SIGSYS
4069         if (x == SIGSYS)
4070                 {*r = Mono_Posix_Signum_SIGSYS; return 0;}
4071 #endif /* ndef SIGSYS */
4072 #ifdef SIGTERM
4073         if (x == SIGTERM)
4074                 {*r = Mono_Posix_Signum_SIGTERM; return 0;}
4075 #endif /* ndef SIGTERM */
4076 #ifdef SIGTRAP
4077         if (x == SIGTRAP)
4078                 {*r = Mono_Posix_Signum_SIGTRAP; return 0;}
4079 #endif /* ndef SIGTRAP */
4080 #ifdef SIGTSTP
4081         if (x == SIGTSTP)
4082                 {*r = Mono_Posix_Signum_SIGTSTP; return 0;}
4083 #endif /* ndef SIGTSTP */
4084 #ifdef SIGTTIN
4085         if (x == SIGTTIN)
4086                 {*r = Mono_Posix_Signum_SIGTTIN; return 0;}
4087 #endif /* ndef SIGTTIN */
4088 #ifdef SIGTTOU
4089         if (x == SIGTTOU)
4090                 {*r = Mono_Posix_Signum_SIGTTOU; return 0;}
4091 #endif /* ndef SIGTTOU */
4092 #ifdef SIGUNUSED
4093         if (x == SIGUNUSED)
4094                 {*r = Mono_Posix_Signum_SIGUNUSED; return 0;}
4095 #endif /* ndef SIGUNUSED */
4096 #ifdef SIGURG
4097         if (x == SIGURG)
4098                 {*r = Mono_Posix_Signum_SIGURG; return 0;}
4099 #endif /* ndef SIGURG */
4100 #ifdef SIGUSR1
4101         if (x == SIGUSR1)
4102                 {*r = Mono_Posix_Signum_SIGUSR1; return 0;}
4103 #endif /* ndef SIGUSR1 */
4104 #ifdef SIGUSR2
4105         if (x == SIGUSR2)
4106                 {*r = Mono_Posix_Signum_SIGUSR2; return 0;}
4107 #endif /* ndef SIGUSR2 */
4108 #ifdef SIGVTALRM
4109         if (x == SIGVTALRM)
4110                 {*r = Mono_Posix_Signum_SIGVTALRM; return 0;}
4111 #endif /* ndef SIGVTALRM */
4112 #ifdef SIGWINCH
4113         if (x == SIGWINCH)
4114                 {*r = Mono_Posix_Signum_SIGWINCH; return 0;}
4115 #endif /* ndef SIGWINCH */
4116 #ifdef SIGXCPU
4117         if (x == SIGXCPU)
4118                 {*r = Mono_Posix_Signum_SIGXCPU; return 0;}
4119 #endif /* ndef SIGXCPU */
4120 #ifdef SIGXFSZ
4121         if (x == SIGXFSZ)
4122                 {*r = Mono_Posix_Signum_SIGXFSZ; return 0;}
4123 #endif /* ndef SIGXFSZ */
4124         errno = EINVAL; return -1;
4125 }
4126
4127 int
4128 Mono_Posix_FromStat (struct Mono_Posix_Stat *from, struct stat *to)
4129 {
4130         _cnm_return_val_if_overflow (dev_t, from->st_dev, -1);
4131         _cnm_return_val_if_overflow (ino_t, from->st_ino, -1);
4132         _cnm_return_val_if_overflow (nlink_t, from->st_nlink, -1);
4133         _cnm_return_val_if_overflow (uid_t, from->st_uid, -1);
4134         _cnm_return_val_if_overflow (gid_t, from->st_gid, -1);
4135         _cnm_return_val_if_overflow (dev_t, from->st_rdev, -1);
4136         _cnm_return_val_if_overflow (off_t, from->st_size, -1);
4137         _cnm_return_val_if_overflow (blksize_t, from->st_blksize, -1);
4138         _cnm_return_val_if_overflow (blkcnt_t, from->st_blocks, -1);
4139         _cnm_return_val_if_overflow (time_t, from->st_atime_, -1);
4140         _cnm_return_val_if_overflow (time_t, from->st_mtime_, -1);
4141         _cnm_return_val_if_overflow (time_t, from->st_ctime_, -1);
4142
4143         memset (to, 0, sizeof(*to));
4144
4145         to->st_dev     = from->st_dev;
4146         to->st_ino     = from->st_ino;
4147         if (Mono_Posix_FromFilePermissions (from->st_mode, &to->st_mode) != 0) {
4148                 return -1;
4149         }
4150         to->st_nlink   = from->st_nlink;
4151         to->st_uid     = from->st_uid;
4152         to->st_gid     = from->st_gid;
4153         to->st_rdev    = from->st_rdev;
4154         to->st_size    = from->st_size;
4155         to->st_blksize = from->st_blksize;
4156         to->st_blocks  = from->st_blocks;
4157         to->st_atime   = from->st_atime_;
4158         to->st_mtime   = from->st_mtime_;
4159         to->st_ctime   = from->st_ctime_;
4160
4161         return 0;
4162 }
4163
4164
4165 int
4166 Mono_Posix_ToStat (struct stat *from, struct Mono_Posix_Stat *to)
4167 {
4168         _cnm_return_val_if_overflow (guint64, from->st_dev, -1);
4169         _cnm_return_val_if_overflow (guint64, from->st_ino, -1);
4170         _cnm_return_val_if_overflow (guint64, from->st_nlink, -1);
4171         _cnm_return_val_if_overflow (unsigned int, from->st_uid, -1);
4172         _cnm_return_val_if_overflow (unsigned int, from->st_gid, -1);
4173         _cnm_return_val_if_overflow (guint64, from->st_rdev, -1);
4174         _cnm_return_val_if_overflow (gint64, from->st_size, -1);
4175         _cnm_return_val_if_overflow (gint64, from->st_blksize, -1);
4176         _cnm_return_val_if_overflow (gint64, from->st_blocks, -1);
4177         _cnm_return_val_if_overflow (gint64, from->st_atime, -1);
4178         _cnm_return_val_if_overflow (gint64, from->st_mtime, -1);
4179         _cnm_return_val_if_overflow (gint64, from->st_ctime, -1);
4180
4181         memset (to, 0, sizeof(*to));
4182
4183         to->st_dev     = from->st_dev;
4184         to->st_ino     = from->st_ino;
4185         if (Mono_Posix_ToFilePermissions (from->st_mode, &to->st_mode) != 0) {
4186                 return -1;
4187         }
4188         to->st_nlink   = from->st_nlink;
4189         to->st_uid     = from->st_uid;
4190         to->st_gid     = from->st_gid;
4191         to->st_rdev    = from->st_rdev;
4192         to->st_size    = from->st_size;
4193         to->st_blksize = from->st_blksize;
4194         to->st_blocks  = from->st_blocks;
4195         to->st_atime_  = from->st_atime;
4196         to->st_mtime_  = from->st_mtime;
4197         to->st_ctime_  = from->st_ctime;
4198
4199         return 0;
4200 }
4201
4202
4203 int Mono_Posix_FromSysconfName (int x, int *r)
4204 {
4205         *r = 0;
4206         if (x == Mono_Posix_SysconfName__SC_2_CHAR_TERM)
4207 #ifdef _SC_2_CHAR_TERM
4208                 {*r = _SC_2_CHAR_TERM; return 0;}
4209 #else /* def _SC_2_CHAR_TERM */
4210                 {errno = EINVAL; return -1;}
4211 #endif /* ndef _SC_2_CHAR_TERM */
4212         if (x == Mono_Posix_SysconfName__SC_2_C_BIND)
4213 #ifdef _SC_2_C_BIND
4214                 {*r = _SC_2_C_BIND; return 0;}
4215 #else /* def _SC_2_C_BIND */
4216                 {errno = EINVAL; return -1;}
4217 #endif /* ndef _SC_2_C_BIND */
4218         if (x == Mono_Posix_SysconfName__SC_2_C_DEV)
4219 #ifdef _SC_2_C_DEV
4220                 {*r = _SC_2_C_DEV; return 0;}
4221 #else /* def _SC_2_C_DEV */
4222                 {errno = EINVAL; return -1;}
4223 #endif /* ndef _SC_2_C_DEV */
4224         if (x == Mono_Posix_SysconfName__SC_2_C_VERSION)
4225 #ifdef _SC_2_C_VERSION
4226                 {*r = _SC_2_C_VERSION; return 0;}
4227 #else /* def _SC_2_C_VERSION */
4228                 {errno = EINVAL; return -1;}
4229 #endif /* ndef _SC_2_C_VERSION */
4230         if (x == Mono_Posix_SysconfName__SC_2_FORT_DEV)
4231 #ifdef _SC_2_FORT_DEV
4232                 {*r = _SC_2_FORT_DEV; return 0;}
4233 #else /* def _SC_2_FORT_DEV */
4234                 {errno = EINVAL; return -1;}
4235 #endif /* ndef _SC_2_FORT_DEV */
4236         if (x == Mono_Posix_SysconfName__SC_2_FORT_RUN)
4237 #ifdef _SC_2_FORT_RUN
4238                 {*r = _SC_2_FORT_RUN; return 0;}
4239 #else /* def _SC_2_FORT_RUN */
4240                 {errno = EINVAL; return -1;}
4241 #endif /* ndef _SC_2_FORT_RUN */
4242         if (x == Mono_Posix_SysconfName__SC_2_LOCALEDEF)
4243 #ifdef _SC_2_LOCALEDEF
4244                 {*r = _SC_2_LOCALEDEF; return 0;}
4245 #else /* def _SC_2_LOCALEDEF */
4246                 {errno = EINVAL; return -1;}
4247 #endif /* ndef _SC_2_LOCALEDEF */
4248         if (x == Mono_Posix_SysconfName__SC_2_PBS)
4249 #ifdef _SC_2_PBS
4250                 {*r = _SC_2_PBS; return 0;}
4251 #else /* def _SC_2_PBS */
4252                 {errno = EINVAL; return -1;}
4253 #endif /* ndef _SC_2_PBS */
4254         if (x == Mono_Posix_SysconfName__SC_2_PBS_ACCOUNTING)
4255 #ifdef _SC_2_PBS_ACCOUNTING
4256                 {*r = _SC_2_PBS_ACCOUNTING; return 0;}
4257 #else /* def _SC_2_PBS_ACCOUNTING */
4258                 {errno = EINVAL; return -1;}
4259 #endif /* ndef _SC_2_PBS_ACCOUNTING */
4260         if (x == Mono_Posix_SysconfName__SC_2_PBS_CHECKPOINT)
4261 #ifdef _SC_2_PBS_CHECKPOINT
4262                 {*r = _SC_2_PBS_CHECKPOINT; return 0;}
4263 #else /* def _SC_2_PBS_CHECKPOINT */
4264                 {errno = EINVAL; return -1;}
4265 #endif /* ndef _SC_2_PBS_CHECKPOINT */
4266         if (x == Mono_Posix_SysconfName__SC_2_PBS_LOCATE)
4267 #ifdef _SC_2_PBS_LOCATE
4268                 {*r = _SC_2_PBS_LOCATE; return 0;}
4269 #else /* def _SC_2_PBS_LOCATE */
4270                 {errno = EINVAL; return -1;}
4271 #endif /* ndef _SC_2_PBS_LOCATE */
4272         if (x == Mono_Posix_SysconfName__SC_2_PBS_MESSAGE)
4273 #ifdef _SC_2_PBS_MESSAGE
4274                 {*r = _SC_2_PBS_MESSAGE; return 0;}
4275 #else /* def _SC_2_PBS_MESSAGE */
4276                 {errno = EINVAL; return -1;}
4277 #endif /* ndef _SC_2_PBS_MESSAGE */
4278         if (x == Mono_Posix_SysconfName__SC_2_PBS_TRACK)
4279 #ifdef _SC_2_PBS_TRACK
4280                 {*r = _SC_2_PBS_TRACK; return 0;}
4281 #else /* def _SC_2_PBS_TRACK */
4282                 {errno = EINVAL; return -1;}
4283 #endif /* ndef _SC_2_PBS_TRACK */
4284         if (x == Mono_Posix_SysconfName__SC_2_SW_DEV)
4285 #ifdef _SC_2_SW_DEV
4286                 {*r = _SC_2_SW_DEV; return 0;}
4287 #else /* def _SC_2_SW_DEV */
4288                 {errno = EINVAL; return -1;}
4289 #endif /* ndef _SC_2_SW_DEV */
4290         if (x == Mono_Posix_SysconfName__SC_2_UPE)
4291 #ifdef _SC_2_UPE
4292                 {*r = _SC_2_UPE; return 0;}
4293 #else /* def _SC_2_UPE */
4294                 {errno = EINVAL; return -1;}
4295 #endif /* ndef _SC_2_UPE */
4296         if (x == Mono_Posix_SysconfName__SC_2_VERSION)
4297 #ifdef _SC_2_VERSION
4298                 {*r = _SC_2_VERSION; return 0;}
4299 #else /* def _SC_2_VERSION */
4300                 {errno = EINVAL; return -1;}
4301 #endif /* ndef _SC_2_VERSION */
4302         if (x == Mono_Posix_SysconfName__SC_ADVISORY_INFO)
4303 #ifdef _SC_ADVISORY_INFO
4304                 {*r = _SC_ADVISORY_INFO; return 0;}
4305 #else /* def _SC_ADVISORY_INFO */
4306                 {errno = EINVAL; return -1;}
4307 #endif /* ndef _SC_ADVISORY_INFO */
4308         if (x == Mono_Posix_SysconfName__SC_AIO_LISTIO_MAX)
4309 #ifdef _SC_AIO_LISTIO_MAX
4310                 {*r = _SC_AIO_LISTIO_MAX; return 0;}
4311 #else /* def _SC_AIO_LISTIO_MAX */
4312                 {errno = EINVAL; return -1;}
4313 #endif /* ndef _SC_AIO_LISTIO_MAX */
4314         if (x == Mono_Posix_SysconfName__SC_AIO_MAX)
4315 #ifdef _SC_AIO_MAX
4316                 {*r = _SC_AIO_MAX; return 0;}
4317 #else /* def _SC_AIO_MAX */
4318                 {errno = EINVAL; return -1;}
4319 #endif /* ndef _SC_AIO_MAX */
4320         if (x == Mono_Posix_SysconfName__SC_AIO_PRIO_DELTA_MAX)
4321 #ifdef _SC_AIO_PRIO_DELTA_MAX
4322                 {*r = _SC_AIO_PRIO_DELTA_MAX; return 0;}
4323 #else /* def _SC_AIO_PRIO_DELTA_MAX */
4324                 {errno = EINVAL; return -1;}
4325 #endif /* ndef _SC_AIO_PRIO_DELTA_MAX */
4326         if (x == Mono_Posix_SysconfName__SC_ARG_MAX)
4327 #ifdef _SC_ARG_MAX
4328                 {*r = _SC_ARG_MAX; return 0;}
4329 #else /* def _SC_ARG_MAX */
4330                 {errno = EINVAL; return -1;}
4331 #endif /* ndef _SC_ARG_MAX */
4332         if (x == Mono_Posix_SysconfName__SC_ASYNCHRONOUS_IO)
4333 #ifdef _SC_ASYNCHRONOUS_IO
4334                 {*r = _SC_ASYNCHRONOUS_IO; return 0;}
4335 #else /* def _SC_ASYNCHRONOUS_IO */
4336                 {errno = EINVAL; return -1;}
4337 #endif /* ndef _SC_ASYNCHRONOUS_IO */
4338         if (x == Mono_Posix_SysconfName__SC_ATEXIT_MAX)
4339 #ifdef _SC_ATEXIT_MAX
4340                 {*r = _SC_ATEXIT_MAX; return 0;}
4341 #else /* def _SC_ATEXIT_MAX */
4342                 {errno = EINVAL; return -1;}
4343 #endif /* ndef _SC_ATEXIT_MAX */
4344         if (x == Mono_Posix_SysconfName__SC_AVPHYS_PAGES)
4345 #ifdef _SC_AVPHYS_PAGES
4346                 {*r = _SC_AVPHYS_PAGES; return 0;}
4347 #else /* def _SC_AVPHYS_PAGES */
4348                 {errno = EINVAL; return -1;}
4349 #endif /* ndef _SC_AVPHYS_PAGES */
4350         if (x == Mono_Posix_SysconfName__SC_BARRIERS)
4351 #ifdef _SC_BARRIERS
4352                 {*r = _SC_BARRIERS; return 0;}
4353 #else /* def _SC_BARRIERS */
4354                 {errno = EINVAL; return -1;}
4355 #endif /* ndef _SC_BARRIERS */
4356         if (x == Mono_Posix_SysconfName__SC_BASE)
4357 #ifdef _SC_BASE
4358                 {*r = _SC_BASE; return 0;}
4359 #else /* def _SC_BASE */
4360                 {errno = EINVAL; return -1;}
4361 #endif /* ndef _SC_BASE */
4362         if (x == Mono_Posix_SysconfName__SC_BC_BASE_MAX)
4363 #ifdef _SC_BC_BASE_MAX
4364                 {*r = _SC_BC_BASE_MAX; return 0;}
4365 #else /* def _SC_BC_BASE_MAX */
4366                 {errno = EINVAL; return -1;}
4367 #endif /* ndef _SC_BC_BASE_MAX */
4368         if (x == Mono_Posix_SysconfName__SC_BC_DIM_MAX)
4369 #ifdef _SC_BC_DIM_MAX
4370                 {*r = _SC_BC_DIM_MAX; return 0;}
4371 #else /* def _SC_BC_DIM_MAX */
4372                 {errno = EINVAL; return -1;}
4373 #endif /* ndef _SC_BC_DIM_MAX */
4374         if (x == Mono_Posix_SysconfName__SC_BC_SCALE_MAX)
4375 #ifdef _SC_BC_SCALE_MAX
4376                 {*r = _SC_BC_SCALE_MAX; return 0;}
4377 #else /* def _SC_BC_SCALE_MAX */
4378                 {errno = EINVAL; return -1;}
4379 #endif /* ndef _SC_BC_SCALE_MAX */
4380         if (x == Mono_Posix_SysconfName__SC_BC_STRING_MAX)
4381 #ifdef _SC_BC_STRING_MAX
4382                 {*r = _SC_BC_STRING_MAX; return 0;}
4383 #else /* def _SC_BC_STRING_MAX */
4384                 {errno = EINVAL; return -1;}
4385 #endif /* ndef _SC_BC_STRING_MAX */
4386         if (x == Mono_Posix_SysconfName__SC_CHARCLASS_NAME_MAX)
4387 #ifdef _SC_CHARCLASS_NAME_MAX
4388                 {*r = _SC_CHARCLASS_NAME_MAX; return 0;}
4389 #else /* def _SC_CHARCLASS_NAME_MAX */
4390                 {errno = EINVAL; return -1;}
4391 #endif /* ndef _SC_CHARCLASS_NAME_MAX */
4392         if (x == Mono_Posix_SysconfName__SC_CHAR_BIT)
4393 #ifdef _SC_CHAR_BIT
4394                 {*r = _SC_CHAR_BIT; return 0;}
4395 #else /* def _SC_CHAR_BIT */
4396                 {errno = EINVAL; return -1;}
4397 #endif /* ndef _SC_CHAR_BIT */
4398         if (x == Mono_Posix_SysconfName__SC_CHAR_MAX)
4399 #ifdef _SC_CHAR_MAX
4400                 {*r = _SC_CHAR_MAX; return 0;}
4401 #else /* def _SC_CHAR_MAX */
4402                 {errno = EINVAL; return -1;}
4403 #endif /* ndef _SC_CHAR_MAX */
4404         if (x == Mono_Posix_SysconfName__SC_CHAR_MIN)
4405 #ifdef _SC_CHAR_MIN
4406                 {*r = _SC_CHAR_MIN; return 0;}
4407 #else /* def _SC_CHAR_MIN */
4408                 {errno = EINVAL; return -1;}
4409 #endif /* ndef _SC_CHAR_MIN */
4410         if (x == Mono_Posix_SysconfName__SC_CHILD_MAX)
4411 #ifdef _SC_CHILD_MAX
4412                 {*r = _SC_CHILD_MAX; return 0;}
4413 #else /* def _SC_CHILD_MAX */
4414                 {errno = EINVAL; return -1;}
4415 #endif /* ndef _SC_CHILD_MAX */
4416         if (x == Mono_Posix_SysconfName__SC_CLK_TCK)
4417 #ifdef _SC_CLK_TCK
4418                 {*r = _SC_CLK_TCK; return 0;}
4419 #else /* def _SC_CLK_TCK */
4420                 {errno = EINVAL; return -1;}
4421 #endif /* ndef _SC_CLK_TCK */
4422         if (x == Mono_Posix_SysconfName__SC_CLOCK_SELECTION)
4423 #ifdef _SC_CLOCK_SELECTION
4424                 {*r = _SC_CLOCK_SELECTION; return 0;}
4425 #else /* def _SC_CLOCK_SELECTION */
4426                 {errno = EINVAL; return -1;}
4427 #endif /* ndef _SC_CLOCK_SELECTION */
4428         if (x == Mono_Posix_SysconfName__SC_COLL_WEIGHTS_MAX)
4429 #ifdef _SC_COLL_WEIGHTS_MAX
4430                 {*r = _SC_COLL_WEIGHTS_MAX; return 0;}
4431 #else /* def _SC_COLL_WEIGHTS_MAX */
4432                 {errno = EINVAL; return -1;}
4433 #endif /* ndef _SC_COLL_WEIGHTS_MAX */
4434         if (x == Mono_Posix_SysconfName__SC_CPUTIME)
4435 #ifdef _SC_CPUTIME
4436                 {*r = _SC_CPUTIME; return 0;}
4437 #else /* def _SC_CPUTIME */
4438                 {errno = EINVAL; return -1;}
4439 #endif /* ndef _SC_CPUTIME */
4440         if (x == Mono_Posix_SysconfName__SC_C_LANG_SUPPORT)
4441 #ifdef _SC_C_LANG_SUPPORT
4442                 {*r = _SC_C_LANG_SUPPORT; return 0;}
4443 #else /* def _SC_C_LANG_SUPPORT */
4444                 {errno = EINVAL; return -1;}
4445 #endif /* ndef _SC_C_LANG_SUPPORT */
4446         if (x == Mono_Posix_SysconfName__SC_C_LANG_SUPPORT_R)
4447 #ifdef _SC_C_LANG_SUPPORT_R
4448                 {*r = _SC_C_LANG_SUPPORT_R; return 0;}
4449 #else /* def _SC_C_LANG_SUPPORT_R */
4450                 {errno = EINVAL; return -1;}
4451 #endif /* ndef _SC_C_LANG_SUPPORT_R */
4452         if (x == Mono_Posix_SysconfName__SC_DELAYTIMER_MAX)
4453 #ifdef _SC_DELAYTIMER_MAX
4454                 {*r = _SC_DELAYTIMER_MAX; return 0;}
4455 #else /* def _SC_DELAYTIMER_MAX */
4456                 {errno = EINVAL; return -1;}
4457 #endif /* ndef _SC_DELAYTIMER_MAX */
4458         if (x == Mono_Posix_SysconfName__SC_DEVICE_IO)
4459 #ifdef _SC_DEVICE_IO
4460                 {*r = _SC_DEVICE_IO; return 0;}
4461 #else /* def _SC_DEVICE_IO */
4462                 {errno = EINVAL; return -1;}
4463 #endif /* ndef _SC_DEVICE_IO */
4464         if (x == Mono_Posix_SysconfName__SC_DEVICE_SPECIFIC)
4465 #ifdef _SC_DEVICE_SPECIFIC
4466                 {*r = _SC_DEVICE_SPECIFIC; return 0;}
4467 #else /* def _SC_DEVICE_SPECIFIC */
4468                 {errno = EINVAL; return -1;}
4469 #endif /* ndef _SC_DEVICE_SPECIFIC */
4470         if (x == Mono_Posix_SysconfName__SC_DEVICE_SPECIFIC_R)
4471 #ifdef _SC_DEVICE_SPECIFIC_R
4472                 {*r = _SC_DEVICE_SPECIFIC_R; return 0;}
4473 #else /* def _SC_DEVICE_SPECIFIC_R */
4474                 {errno = EINVAL; return -1;}
4475 #endif /* ndef _SC_DEVICE_SPECIFIC_R */
4476         if (x == Mono_Posix_SysconfName__SC_EQUIV_CLASS_MAX)
4477 #ifdef _SC_EQUIV_CLASS_MAX
4478                 {*r = _SC_EQUIV_CLASS_MAX; return 0;}
4479 #else /* def _SC_EQUIV_CLASS_MAX */
4480                 {errno = EINVAL; return -1;}
4481 #endif /* ndef _SC_EQUIV_CLASS_MAX */
4482         if (x == Mono_Posix_SysconfName__SC_EXPR_NEST_MAX)
4483 #ifdef _SC_EXPR_NEST_MAX
4484                 {*r = _SC_EXPR_NEST_MAX; return 0;}
4485 #else /* def _SC_EXPR_NEST_MAX */
4486                 {errno = EINVAL; return -1;}
4487 #endif /* ndef _SC_EXPR_NEST_MAX */
4488         if (x == Mono_Posix_SysconfName__SC_FD_MGMT)
4489 #ifdef _SC_FD_MGMT
4490                 {*r = _SC_FD_MGMT; return 0;}
4491 #else /* def _SC_FD_MGMT */
4492                 {errno = EINVAL; return -1;}
4493 #endif /* ndef _SC_FD_MGMT */
4494         if (x == Mono_Posix_SysconfName__SC_FIFO)
4495 #ifdef _SC_FIFO
4496                 {*r = _SC_FIFO; return 0;}
4497 #else /* def _SC_FIFO */
4498                 {errno = EINVAL; return -1;}
4499 #endif /* ndef _SC_FIFO */
4500         if (x == Mono_Posix_SysconfName__SC_FILE_ATTRIBUTES)
4501 #ifdef _SC_FILE_ATTRIBUTES
4502                 {*r = _SC_FILE_ATTRIBUTES; return 0;}
4503 #else /* def _SC_FILE_ATTRIBUTES */
4504                 {errno = EINVAL; return -1;}
4505 #endif /* ndef _SC_FILE_ATTRIBUTES */
4506         if (x == Mono_Posix_SysconfName__SC_FILE_LOCKING)
4507 #ifdef _SC_FILE_LOCKING
4508                 {*r = _SC_FILE_LOCKING; return 0;}
4509 #else /* def _SC_FILE_LOCKING */
4510                 {errno = EINVAL; return -1;}
4511 #endif /* ndef _SC_FILE_LOCKING */
4512         if (x == Mono_Posix_SysconfName__SC_FILE_SYSTEM)
4513 #ifdef _SC_FILE_SYSTEM
4514                 {*r = _SC_FILE_SYSTEM; return 0;}
4515 #else /* def _SC_FILE_SYSTEM */
4516                 {errno = EINVAL; return -1;}
4517 #endif /* ndef _SC_FILE_SYSTEM */
4518         if (x == Mono_Posix_SysconfName__SC_FSYNC)
4519 #ifdef _SC_FSYNC
4520                 {*r = _SC_FSYNC; return 0;}
4521 #else /* def _SC_FSYNC */
4522                 {errno = EINVAL; return -1;}
4523 #endif /* ndef _SC_FSYNC */
4524         if (x == Mono_Posix_SysconfName__SC_GETGR_R_SIZE_MAX)
4525 #ifdef _SC_GETGR_R_SIZE_MAX
4526                 {*r = _SC_GETGR_R_SIZE_MAX; return 0;}
4527 #else /* def _SC_GETGR_R_SIZE_MAX */
4528                 {errno = EINVAL; return -1;}
4529 #endif /* ndef _SC_GETGR_R_SIZE_MAX */
4530         if (x == Mono_Posix_SysconfName__SC_GETPW_R_SIZE_MAX)
4531 #ifdef _SC_GETPW_R_SIZE_MAX
4532                 {*r = _SC_GETPW_R_SIZE_MAX; return 0;}
4533 #else /* def _SC_GETPW_R_SIZE_MAX */
4534                 {errno = EINVAL; return -1;}
4535 #endif /* ndef _SC_GETPW_R_SIZE_MAX */
4536         if (x == Mono_Posix_SysconfName__SC_HOST_NAME_MAX)
4537 #ifdef _SC_HOST_NAME_MAX
4538                 {*r = _SC_HOST_NAME_MAX; return 0;}
4539 #else /* def _SC_HOST_NAME_MAX */
4540                 {errno = EINVAL; return -1;}
4541 #endif /* ndef _SC_HOST_NAME_MAX */
4542         if (x == Mono_Posix_SysconfName__SC_INT_MAX)
4543 #ifdef _SC_INT_MAX
4544                 {*r = _SC_INT_MAX; return 0;}
4545 #else /* def _SC_INT_MAX */
4546                 {errno = EINVAL; return -1;}
4547 #endif /* ndef _SC_INT_MAX */
4548         if (x == Mono_Posix_SysconfName__SC_INT_MIN)
4549 #ifdef _SC_INT_MIN
4550                 {*r = _SC_INT_MIN; return 0;}
4551 #else /* def _SC_INT_MIN */
4552                 {errno = EINVAL; return -1;}
4553 #endif /* ndef _SC_INT_MIN */
4554         if (x == Mono_Posix_SysconfName__SC_IOV_MAX)
4555 #ifdef _SC_IOV_MAX
4556                 {*r = _SC_IOV_MAX; return 0;}
4557 #else /* def _SC_IOV_MAX */
4558                 {errno = EINVAL; return -1;}
4559 #endif /* ndef _SC_IOV_MAX */
4560         if (x == Mono_Posix_SysconfName__SC_JOB_CONTROL)
4561 #ifdef _SC_JOB_CONTROL
4562                 {*r = _SC_JOB_CONTROL; return 0;}
4563 #else /* def _SC_JOB_CONTROL */
4564                 {errno = EINVAL; return -1;}
4565 #endif /* ndef _SC_JOB_CONTROL */
4566         if (x == Mono_Posix_SysconfName__SC_LEVEL1_DCACHE_ASSOC)
4567 #ifdef _SC_LEVEL1_DCACHE_ASSOC
4568                 {*r = _SC_LEVEL1_DCACHE_ASSOC; return 0;}
4569 #else /* def _SC_LEVEL1_DCACHE_ASSOC */
4570                 {errno = EINVAL; return -1;}
4571 #endif /* ndef _SC_LEVEL1_DCACHE_ASSOC */
4572         if (x == Mono_Posix_SysconfName__SC_LEVEL1_DCACHE_LINESIZE)
4573 #ifdef _SC_LEVEL1_DCACHE_LINESIZE
4574                 {*r = _SC_LEVEL1_DCACHE_LINESIZE; return 0;}
4575 #else /* def _SC_LEVEL1_DCACHE_LINESIZE */
4576                 {errno = EINVAL; return -1;}
4577 #endif /* ndef _SC_LEVEL1_DCACHE_LINESIZE */
4578         if (x == Mono_Posix_SysconfName__SC_LEVEL1_DCACHE_SIZE)
4579 #ifdef _SC_LEVEL1_DCACHE_SIZE
4580                 {*r = _SC_LEVEL1_DCACHE_SIZE; return 0;}
4581 #else /* def _SC_LEVEL1_DCACHE_SIZE */
4582                 {errno = EINVAL; return -1;}
4583 #endif /* ndef _SC_LEVEL1_DCACHE_SIZE */
4584         if (x == Mono_Posix_SysconfName__SC_LEVEL1_ICACHE_ASSOC)
4585 #ifdef _SC_LEVEL1_ICACHE_ASSOC
4586                 {*r = _SC_LEVEL1_ICACHE_ASSOC; return 0;}
4587 #else /* def _SC_LEVEL1_ICACHE_ASSOC */
4588                 {errno = EINVAL; return -1;}
4589 #endif /* ndef _SC_LEVEL1_ICACHE_ASSOC */
4590         if (x == Mono_Posix_SysconfName__SC_LEVEL1_ICACHE_LINESIZE)
4591 #ifdef _SC_LEVEL1_ICACHE_LINESIZE
4592                 {*r = _SC_LEVEL1_ICACHE_LINESIZE; return 0;}
4593 #else /* def _SC_LEVEL1_ICACHE_LINESIZE */
4594                 {errno = EINVAL; return -1;}
4595 #endif /* ndef _SC_LEVEL1_ICACHE_LINESIZE */
4596         if (x == Mono_Posix_SysconfName__SC_LEVEL1_ICACHE_SIZE)
4597 #ifdef _SC_LEVEL1_ICACHE_SIZE
4598                 {*r = _SC_LEVEL1_ICACHE_SIZE; return 0;}
4599 #else /* def _SC_LEVEL1_ICACHE_SIZE */
4600                 {errno = EINVAL; return -1;}
4601 #endif /* ndef _SC_LEVEL1_ICACHE_SIZE */
4602         if (x == Mono_Posix_SysconfName__SC_LEVEL2_CACHE_ASSOC)
4603 #ifdef _SC_LEVEL2_CACHE_ASSOC
4604                 {*r = _SC_LEVEL2_CACHE_ASSOC; return 0;}
4605 #else /* def _SC_LEVEL2_CACHE_ASSOC */
4606                 {errno = EINVAL; return -1;}
4607 #endif /* ndef _SC_LEVEL2_CACHE_ASSOC */
4608         if (x == Mono_Posix_SysconfName__SC_LEVEL2_CACHE_LINESIZE)
4609 #ifdef _SC_LEVEL2_CACHE_LINESIZE
4610                 {*r = _SC_LEVEL2_CACHE_LINESIZE; return 0;}
4611 #else /* def _SC_LEVEL2_CACHE_LINESIZE */
4612                 {errno = EINVAL; return -1;}
4613 #endif /* ndef _SC_LEVEL2_CACHE_LINESIZE */
4614         if (x == Mono_Posix_SysconfName__SC_LEVEL2_CACHE_SIZE)
4615 #ifdef _SC_LEVEL2_CACHE_SIZE
4616                 {*r = _SC_LEVEL2_CACHE_SIZE; return 0;}
4617 #else /* def _SC_LEVEL2_CACHE_SIZE */
4618                 {errno = EINVAL; return -1;}
4619 #endif /* ndef _SC_LEVEL2_CACHE_SIZE */
4620         if (x == Mono_Posix_SysconfName__SC_LEVEL3_CACHE_ASSOC)
4621 #ifdef _SC_LEVEL3_CACHE_ASSOC
4622                 {*r = _SC_LEVEL3_CACHE_ASSOC; return 0;}
4623 #else /* def _SC_LEVEL3_CACHE_ASSOC */
4624                 {errno = EINVAL; return -1;}
4625 #endif /* ndef _SC_LEVEL3_CACHE_ASSOC */
4626         if (x == Mono_Posix_SysconfName__SC_LEVEL3_CACHE_LINESIZE)
4627 #ifdef _SC_LEVEL3_CACHE_LINESIZE
4628                 {*r = _SC_LEVEL3_CACHE_LINESIZE; return 0;}
4629 #else /* def _SC_LEVEL3_CACHE_LINESIZE */
4630                 {errno = EINVAL; return -1;}
4631 #endif /* ndef _SC_LEVEL3_CACHE_LINESIZE */
4632         if (x == Mono_Posix_SysconfName__SC_LEVEL3_CACHE_SIZE)
4633 #ifdef _SC_LEVEL3_CACHE_SIZE
4634                 {*r = _SC_LEVEL3_CACHE_SIZE; return 0;}
4635 #else /* def _SC_LEVEL3_CACHE_SIZE */
4636                 {errno = EINVAL; return -1;}
4637 #endif /* ndef _SC_LEVEL3_CACHE_SIZE */
4638         if (x == Mono_Posix_SysconfName__SC_LEVEL4_CACHE_ASSOC)
4639 #ifdef _SC_LEVEL4_CACHE_ASSOC
4640                 {*r = _SC_LEVEL4_CACHE_ASSOC; return 0;}
4641 #else /* def _SC_LEVEL4_CACHE_ASSOC */
4642                 {errno = EINVAL; return -1;}
4643 #endif /* ndef _SC_LEVEL4_CACHE_ASSOC */
4644         if (x == Mono_Posix_SysconfName__SC_LEVEL4_CACHE_LINESIZE)
4645 #ifdef _SC_LEVEL4_CACHE_LINESIZE
4646                 {*r = _SC_LEVEL4_CACHE_LINESIZE; return 0;}
4647 #else /* def _SC_LEVEL4_CACHE_LINESIZE */
4648                 {errno = EINVAL; return -1;}
4649 #endif /* ndef _SC_LEVEL4_CACHE_LINESIZE */
4650         if (x == Mono_Posix_SysconfName__SC_LEVEL4_CACHE_SIZE)
4651 #ifdef _SC_LEVEL4_CACHE_SIZE
4652                 {*r = _SC_LEVEL4_CACHE_SIZE; return 0;}
4653 #else /* def _SC_LEVEL4_CACHE_SIZE */
4654                 {errno = EINVAL; return -1;}
4655 #endif /* ndef _SC_LEVEL4_CACHE_SIZE */
4656         if (x == Mono_Posix_SysconfName__SC_LINE_MAX)
4657 #ifdef _SC_LINE_MAX
4658                 {*r = _SC_LINE_MAX; return 0;}
4659 #else /* def _SC_LINE_MAX */
4660                 {errno = EINVAL; return -1;}
4661 #endif /* ndef _SC_LINE_MAX */
4662         if (x == Mono_Posix_SysconfName__SC_LOGIN_NAME_MAX)
4663 #ifdef _SC_LOGIN_NAME_MAX
4664                 {*r = _SC_LOGIN_NAME_MAX; return 0;}
4665 #else /* def _SC_LOGIN_NAME_MAX */
4666                 {errno = EINVAL; return -1;}
4667 #endif /* ndef _SC_LOGIN_NAME_MAX */
4668         if (x == Mono_Posix_SysconfName__SC_LONG_BIT)
4669 #ifdef _SC_LONG_BIT
4670                 {*r = _SC_LONG_BIT; return 0;}
4671 #else /* def _SC_LONG_BIT */
4672                 {errno = EINVAL; return -1;}
4673 #endif /* ndef _SC_LONG_BIT */
4674         if (x == Mono_Posix_SysconfName__SC_MAPPED_FILES)
4675 #ifdef _SC_MAPPED_FILES
4676                 {*r = _SC_MAPPED_FILES; return 0;}
4677 #else /* def _SC_MAPPED_FILES */
4678                 {errno = EINVAL; return -1;}
4679 #endif /* ndef _SC_MAPPED_FILES */
4680         if (x == Mono_Posix_SysconfName__SC_MB_LEN_MAX)
4681 #ifdef _SC_MB_LEN_MAX
4682                 {*r = _SC_MB_LEN_MAX; return 0;}
4683 #else /* def _SC_MB_LEN_MAX */
4684                 {errno = EINVAL; return -1;}
4685 #endif /* ndef _SC_MB_LEN_MAX */
4686         if (x == Mono_Posix_SysconfName__SC_MEMLOCK)
4687 #ifdef _SC_MEMLOCK
4688                 {*r = _SC_MEMLOCK; return 0;}
4689 #else /* def _SC_MEMLOCK */
4690                 {errno = EINVAL; return -1;}
4691 #endif /* ndef _SC_MEMLOCK */
4692         if (x == Mono_Posix_SysconfName__SC_MEMLOCK_RANGE)
4693 #ifdef _SC_MEMLOCK_RANGE
4694                 {*r = _SC_MEMLOCK_RANGE; return 0;}
4695 #else /* def _SC_MEMLOCK_RANGE */
4696                 {errno = EINVAL; return -1;}
4697 #endif /* ndef _SC_MEMLOCK_RANGE */
4698         if (x == Mono_Posix_SysconfName__SC_MEMORY_PROTECTION)
4699 #ifdef _SC_MEMORY_PROTECTION
4700                 {*r = _SC_MEMORY_PROTECTION; return 0;}
4701 #else /* def _SC_MEMORY_PROTECTION */
4702                 {errno = EINVAL; return -1;}
4703 #endif /* ndef _SC_MEMORY_PROTECTION */
4704         if (x == Mono_Posix_SysconfName__SC_MESSAGE_PASSING)
4705 #ifdef _SC_MESSAGE_PASSING
4706                 {*r = _SC_MESSAGE_PASSING; return 0;}
4707 #else /* def _SC_MESSAGE_PASSING */
4708                 {errno = EINVAL; return -1;}
4709 #endif /* ndef _SC_MESSAGE_PASSING */
4710         if (x == Mono_Posix_SysconfName__SC_MONOTONIC_CLOCK)
4711 #ifdef _SC_MONOTONIC_CLOCK
4712                 {*r = _SC_MONOTONIC_CLOCK; return 0;}
4713 #else /* def _SC_MONOTONIC_CLOCK */
4714                 {errno = EINVAL; return -1;}
4715 #endif /* ndef _SC_MONOTONIC_CLOCK */
4716         if (x == Mono_Posix_SysconfName__SC_MQ_OPEN_MAX)
4717 #ifdef _SC_MQ_OPEN_MAX
4718                 {*r = _SC_MQ_OPEN_MAX; return 0;}
4719 #else /* def _SC_MQ_OPEN_MAX */
4720                 {errno = EINVAL; return -1;}
4721 #endif /* ndef _SC_MQ_OPEN_MAX */
4722         if (x == Mono_Posix_SysconfName__SC_MQ_PRIO_MAX)
4723 #ifdef _SC_MQ_PRIO_MAX
4724                 {*r = _SC_MQ_PRIO_MAX; return 0;}
4725 #else /* def _SC_MQ_PRIO_MAX */
4726                 {errno = EINVAL; return -1;}
4727 #endif /* ndef _SC_MQ_PRIO_MAX */
4728         if (x == Mono_Posix_SysconfName__SC_MULTI_PROCESS)
4729 #ifdef _SC_MULTI_PROCESS
4730                 {*r = _SC_MULTI_PROCESS; return 0;}
4731 #else /* def _SC_MULTI_PROCESS */
4732                 {errno = EINVAL; return -1;}
4733 #endif /* ndef _SC_MULTI_PROCESS */
4734         if (x == Mono_Posix_SysconfName__SC_NETWORKING)
4735 #ifdef _SC_NETWORKING
4736                 {*r = _SC_NETWORKING; return 0;}
4737 #else /* def _SC_NETWORKING */
4738                 {errno = EINVAL; return -1;}
4739 #endif /* ndef _SC_NETWORKING */
4740         if (x == Mono_Posix_SysconfName__SC_NGROUPS_MAX)
4741 #ifdef _SC_NGROUPS_MAX
4742                 {*r = _SC_NGROUPS_MAX; return 0;}
4743 #else /* def _SC_NGROUPS_MAX */
4744                 {errno = EINVAL; return -1;}
4745 #endif /* ndef _SC_NGROUPS_MAX */
4746         if (x == Mono_Posix_SysconfName__SC_NL_ARGMAX)
4747 #ifdef _SC_NL_ARGMAX
4748                 {*r = _SC_NL_ARGMAX; return 0;}
4749 #else /* def _SC_NL_ARGMAX */
4750                 {errno = EINVAL; return -1;}
4751 #endif /* ndef _SC_NL_ARGMAX */
4752         if (x == Mono_Posix_SysconfName__SC_NL_LANGMAX)
4753 #ifdef _SC_NL_LANGMAX
4754                 {*r = _SC_NL_LANGMAX; return 0;}
4755 #else /* def _SC_NL_LANGMAX */
4756                 {errno = EINVAL; return -1;}
4757 #endif /* ndef _SC_NL_LANGMAX */
4758         if (x == Mono_Posix_SysconfName__SC_NL_MSGMAX)
4759 #ifdef _SC_NL_MSGMAX
4760                 {*r = _SC_NL_MSGMAX; return 0;}
4761 #else /* def _SC_NL_MSGMAX */
4762                 {errno = EINVAL; return -1;}
4763 #endif /* ndef _SC_NL_MSGMAX */
4764         if (x == Mono_Posix_SysconfName__SC_NL_NMAX)
4765 #ifdef _SC_NL_NMAX
4766                 {*r = _SC_NL_NMAX; return 0;}
4767 #else /* def _SC_NL_NMAX */
4768                 {errno = EINVAL; return -1;}
4769 #endif /* ndef _SC_NL_NMAX */
4770         if (x == Mono_Posix_SysconfName__SC_NL_SETMAX)
4771 #ifdef _SC_NL_SETMAX
4772                 {*r = _SC_NL_SETMAX; return 0;}
4773 #else /* def _SC_NL_SETMAX */
4774                 {errno = EINVAL; return -1;}
4775 #endif /* ndef _SC_NL_SETMAX */
4776         if (x == Mono_Posix_SysconfName__SC_NL_TEXTMAX)
4777 #ifdef _SC_NL_TEXTMAX
4778                 {*r = _SC_NL_TEXTMAX; return 0;}
4779 #else /* def _SC_NL_TEXTMAX */
4780                 {errno = EINVAL; return -1;}
4781 #endif /* ndef _SC_NL_TEXTMAX */
4782         if (x == Mono_Posix_SysconfName__SC_NPROCESSORS_CONF)
4783 #ifdef _SC_NPROCESSORS_CONF
4784                 {*r = _SC_NPROCESSORS_CONF; return 0;}
4785 #else /* def _SC_NPROCESSORS_CONF */
4786                 {errno = EINVAL; return -1;}
4787 #endif /* ndef _SC_NPROCESSORS_CONF */
4788         if (x == Mono_Posix_SysconfName__SC_NPROCESSORS_ONLN)
4789 #ifdef _SC_NPROCESSORS_ONLN
4790                 {*r = _SC_NPROCESSORS_ONLN; return 0;}
4791 #else /* def _SC_NPROCESSORS_ONLN */
4792                 {errno = EINVAL; return -1;}
4793 #endif /* ndef _SC_NPROCESSORS_ONLN */
4794         if (x == Mono_Posix_SysconfName__SC_NZERO)
4795 #ifdef _SC_NZERO
4796                 {*r = _SC_NZERO; return 0;}
4797 #else /* def _SC_NZERO */
4798                 {errno = EINVAL; return -1;}
4799 #endif /* ndef _SC_NZERO */
4800         if (x == Mono_Posix_SysconfName__SC_OPEN_MAX)
4801 #ifdef _SC_OPEN_MAX
4802                 {*r = _SC_OPEN_MAX; return 0;}
4803 #else /* def _SC_OPEN_MAX */
4804                 {errno = EINVAL; return -1;}
4805 #endif /* ndef _SC_OPEN_MAX */
4806         if (x == Mono_Posix_SysconfName__SC_PAGESIZE)
4807 #ifdef _SC_PAGESIZE
4808                 {*r = _SC_PAGESIZE; return 0;}
4809 #else /* def _SC_PAGESIZE */
4810                 {errno = EINVAL; return -1;}
4811 #endif /* ndef _SC_PAGESIZE */
4812         if (x == Mono_Posix_SysconfName__SC_PASS_MAX)
4813 #ifdef _SC_PASS_MAX
4814                 {*r = _SC_PASS_MAX; return 0;}
4815 #else /* def _SC_PASS_MAX */
4816                 {errno = EINVAL; return -1;}
4817 #endif /* ndef _SC_PASS_MAX */
4818         if (x == Mono_Posix_SysconfName__SC_PHYS_PAGES)
4819 #ifdef _SC_PHYS_PAGES
4820                 {*r = _SC_PHYS_PAGES; return 0;}
4821 #else /* def _SC_PHYS_PAGES */
4822                 {errno = EINVAL; return -1;}
4823 #endif /* ndef _SC_PHYS_PAGES */
4824         if (x == Mono_Posix_SysconfName__SC_PII)
4825 #ifdef _SC_PII
4826                 {*r = _SC_PII; return 0;}
4827 #else /* def _SC_PII */
4828                 {errno = EINVAL; return -1;}
4829 #endif /* ndef _SC_PII */
4830         if (x == Mono_Posix_SysconfName__SC_PII_INTERNET)
4831 #ifdef _SC_PII_INTERNET
4832                 {*r = _SC_PII_INTERNET; return 0;}
4833 #else /* def _SC_PII_INTERNET */
4834                 {errno = EINVAL; return -1;}
4835 #endif /* ndef _SC_PII_INTERNET */
4836         if (x == Mono_Posix_SysconfName__SC_PII_INTERNET_DGRAM)
4837 #ifdef _SC_PII_INTERNET_DGRAM
4838                 {*r = _SC_PII_INTERNET_DGRAM; return 0;}
4839 #else /* def _SC_PII_INTERNET_DGRAM */
4840                 {errno = EINVAL; return -1;}
4841 #endif /* ndef _SC_PII_INTERNET_DGRAM */
4842         if (x == Mono_Posix_SysconfName__SC_PII_INTERNET_STREAM)
4843 #ifdef _SC_PII_INTERNET_STREAM
4844                 {*r = _SC_PII_INTERNET_STREAM; return 0;}
4845 #else /* def _SC_PII_INTERNET_STREAM */
4846                 {errno = EINVAL; return -1;}
4847 #endif /* ndef _SC_PII_INTERNET_STREAM */
4848         if (x == Mono_Posix_SysconfName__SC_PII_OSI)
4849 #ifdef _SC_PII_OSI
4850                 {*r = _SC_PII_OSI; return 0;}
4851 #else /* def _SC_PII_OSI */
4852                 {errno = EINVAL; return -1;}
4853 #endif /* ndef _SC_PII_OSI */
4854         if (x == Mono_Posix_SysconfName__SC_PII_OSI_CLTS)
4855 #ifdef _SC_PII_OSI_CLTS
4856                 {*r = _SC_PII_OSI_CLTS; return 0;}
4857 #else /* def _SC_PII_OSI_CLTS */
4858                 {errno = EINVAL; return -1;}
4859 #endif /* ndef _SC_PII_OSI_CLTS */
4860         if (x == Mono_Posix_SysconfName__SC_PII_OSI_COTS)
4861 #ifdef _SC_PII_OSI_COTS
4862                 {*r = _SC_PII_OSI_COTS; return 0;}
4863 #else /* def _SC_PII_OSI_COTS */
4864                 {errno = EINVAL; return -1;}
4865 #endif /* ndef _SC_PII_OSI_COTS */
4866         if (x == Mono_Posix_SysconfName__SC_PII_OSI_M)
4867 #ifdef _SC_PII_OSI_M
4868                 {*r = _SC_PII_OSI_M; return 0;}
4869 #else /* def _SC_PII_OSI_M */
4870                 {errno = EINVAL; return -1;}
4871 #endif /* ndef _SC_PII_OSI_M */
4872         if (x == Mono_Posix_SysconfName__SC_PII_SOCKET)
4873 #ifdef _SC_PII_SOCKET
4874                 {*r = _SC_PII_SOCKET; return 0;}
4875 #else /* def _SC_PII_SOCKET */
4876                 {errno = EINVAL; return -1;}
4877 #endif /* ndef _SC_PII_SOCKET */
4878         if (x == Mono_Posix_SysconfName__SC_PII_XTI)
4879 #ifdef _SC_PII_XTI
4880                 {*r = _SC_PII_XTI; return 0;}
4881 #else /* def _SC_PII_XTI */
4882                 {errno = EINVAL; return -1;}
4883 #endif /* ndef _SC_PII_XTI */
4884         if (x == Mono_Posix_SysconfName__SC_PIPE)
4885 #ifdef _SC_PIPE
4886                 {*r = _SC_PIPE; return 0;}
4887 #else /* def _SC_PIPE */
4888                 {errno = EINVAL; return -1;}
4889 #endif /* ndef _SC_PIPE */
4890         if (x == Mono_Posix_SysconfName__SC_POLL)
4891 #ifdef _SC_POLL
4892                 {*r = _SC_POLL; return 0;}
4893 #else /* def _SC_POLL */
4894                 {errno = EINVAL; return -1;}
4895 #endif /* ndef _SC_POLL */
4896         if (x == Mono_Posix_SysconfName__SC_PRIORITIZED_IO)
4897 #ifdef _SC_PRIORITIZED_IO
4898                 {*r = _SC_PRIORITIZED_IO; return 0;}
4899 #else /* def _SC_PRIORITIZED_IO */
4900                 {errno = EINVAL; return -1;}
4901 #endif /* ndef _SC_PRIORITIZED_IO */
4902         if (x == Mono_Posix_SysconfName__SC_PRIORITY_SCHEDULING)
4903 #ifdef _SC_PRIORITY_SCHEDULING
4904                 {*r = _SC_PRIORITY_SCHEDULING; return 0;}
4905 #else /* def _SC_PRIORITY_SCHEDULING */
4906                 {errno = EINVAL; return -1;}
4907 #endif /* ndef _SC_PRIORITY_SCHEDULING */
4908         if (x == Mono_Posix_SysconfName__SC_READER_WRITER_LOCKS)
4909 #ifdef _SC_READER_WRITER_LOCKS
4910                 {*r = _SC_READER_WRITER_LOCKS; return 0;}
4911 #else /* def _SC_READER_WRITER_LOCKS */
4912                 {errno = EINVAL; return -1;}
4913 #endif /* ndef _SC_READER_WRITER_LOCKS */
4914         if (x == Mono_Posix_SysconfName__SC_REALTIME_SIGNALS)
4915 #ifdef _SC_REALTIME_SIGNALS
4916                 {*r = _SC_REALTIME_SIGNALS; return 0;}
4917 #else /* def _SC_REALTIME_SIGNALS */
4918                 {errno = EINVAL; return -1;}
4919 #endif /* ndef _SC_REALTIME_SIGNALS */
4920         if (x == Mono_Posix_SysconfName__SC_REGEXP)
4921 #ifdef _SC_REGEXP
4922                 {*r = _SC_REGEXP; return 0;}
4923 #else /* def _SC_REGEXP */
4924                 {errno = EINVAL; return -1;}
4925 #endif /* ndef _SC_REGEXP */
4926         if (x == Mono_Posix_SysconfName__SC_REGEX_VERSION)
4927 #ifdef _SC_REGEX_VERSION
4928                 {*r = _SC_REGEX_VERSION; return 0;}
4929 #else /* def _SC_REGEX_VERSION */
4930                 {errno = EINVAL; return -1;}
4931 #endif /* ndef _SC_REGEX_VERSION */
4932         if (x == Mono_Posix_SysconfName__SC_RE_DUP_MAX)
4933 #ifdef _SC_RE_DUP_MAX
4934                 {*r = _SC_RE_DUP_MAX; return 0;}
4935 #else /* def _SC_RE_DUP_MAX */
4936                 {errno = EINVAL; return -1;}
4937 #endif /* ndef _SC_RE_DUP_MAX */
4938         if (x == Mono_Posix_SysconfName__SC_RTSIG_MAX)
4939 #ifdef _SC_RTSIG_MAX
4940                 {*r = _SC_RTSIG_MAX; return 0;}
4941 #else /* def _SC_RTSIG_MAX */
4942                 {errno = EINVAL; return -1;}
4943 #endif /* ndef _SC_RTSIG_MAX */
4944         if (x == Mono_Posix_SysconfName__SC_SAVED_IDS)
4945 #ifdef _SC_SAVED_IDS
4946                 {*r = _SC_SAVED_IDS; return 0;}
4947 #else /* def _SC_SAVED_IDS */
4948                 {errno = EINVAL; return -1;}
4949 #endif /* ndef _SC_SAVED_IDS */
4950         if (x == Mono_Posix_SysconfName__SC_SCHAR_MAX)
4951 #ifdef _SC_SCHAR_MAX
4952                 {*r = _SC_SCHAR_MAX; return 0;}
4953 #else /* def _SC_SCHAR_MAX */
4954                 {errno = EINVAL; return -1;}
4955 #endif /* ndef _SC_SCHAR_MAX */
4956         if (x == Mono_Posix_SysconfName__SC_SCHAR_MIN)
4957 #ifdef _SC_SCHAR_MIN
4958                 {*r = _SC_SCHAR_MIN; return 0;}
4959 #else /* def _SC_SCHAR_MIN */
4960                 {errno = EINVAL; return -1;}
4961 #endif /* ndef _SC_SCHAR_MIN */
4962         if (x == Mono_Posix_SysconfName__SC_SELECT)
4963 #ifdef _SC_SELECT
4964                 {*r = _SC_SELECT; return 0;}
4965 #else /* def _SC_SELECT */
4966                 {errno = EINVAL; return -1;}
4967 #endif /* ndef _SC_SELECT */
4968         if (x == Mono_Posix_SysconfName__SC_SEMAPHORES)
4969 #ifdef _SC_SEMAPHORES
4970                 {*r = _SC_SEMAPHORES; return 0;}
4971 #else /* def _SC_SEMAPHORES */
4972                 {errno = EINVAL; return -1;}
4973 #endif /* ndef _SC_SEMAPHORES */
4974         if (x == Mono_Posix_SysconfName__SC_SEM_NSEMS_MAX)
4975 #ifdef _SC_SEM_NSEMS_MAX
4976                 {*r = _SC_SEM_NSEMS_MAX; return 0;}
4977 #else /* def _SC_SEM_NSEMS_MAX */
4978                 {errno = EINVAL; return -1;}
4979 #endif /* ndef _SC_SEM_NSEMS_MAX */
4980         if (x == Mono_Posix_SysconfName__SC_SEM_VALUE_MAX)
4981 #ifdef _SC_SEM_VALUE_MAX
4982                 {*r = _SC_SEM_VALUE_MAX; return 0;}
4983 #else /* def _SC_SEM_VALUE_MAX */
4984                 {errno = EINVAL; return -1;}
4985 #endif /* ndef _SC_SEM_VALUE_MAX */
4986         if (x == Mono_Posix_SysconfName__SC_SHARED_MEMORY_OBJECTS)
4987 #ifdef _SC_SHARED_MEMORY_OBJECTS
4988                 {*r = _SC_SHARED_MEMORY_OBJECTS; return 0;}
4989 #else /* def _SC_SHARED_MEMORY_OBJECTS */
4990                 {errno = EINVAL; return -1;}
4991 #endif /* ndef _SC_SHARED_MEMORY_OBJECTS */
4992         if (x == Mono_Posix_SysconfName__SC_SHELL)
4993 #ifdef _SC_SHELL
4994                 {*r = _SC_SHELL; return 0;}
4995 #else /* def _SC_SHELL */
4996                 {errno = EINVAL; return -1;}
4997 #endif /* ndef _SC_SHELL */
4998         if (x == Mono_Posix_SysconfName__SC_SHRT_MAX)
4999 #ifdef _SC_SHRT_MAX
5000                 {*r = _SC_SHRT_MAX; return 0;}
5001 #else /* def _SC_SHRT_MAX */
5002                 {errno = EINVAL; return -1;}
5003 #endif /* ndef _SC_SHRT_MAX */
5004         if (x == Mono_Posix_SysconfName__SC_SHRT_MIN)
5005 #ifdef _SC_SHRT_MIN
5006                 {*r = _SC_SHRT_MIN; return 0;}
5007 #else /* def _SC_SHRT_MIN */
5008                 {errno = EINVAL; return -1;}
5009 #endif /* ndef _SC_SHRT_MIN */
5010         if (x == Mono_Posix_SysconfName__SC_SIGNALS)
5011 #ifdef _SC_SIGNALS
5012                 {*r = _SC_SIGNALS; return 0;}
5013 #else /* def _SC_SIGNALS */
5014                 {errno = EINVAL; return -1;}
5015 #endif /* ndef _SC_SIGNALS */
5016         if (x == Mono_Posix_SysconfName__SC_SIGQUEUE_MAX)
5017 #ifdef _SC_SIGQUEUE_MAX
5018                 {*r = _SC_SIGQUEUE_MAX; return 0;}
5019 #else /* def _SC_SIGQUEUE_MAX */
5020                 {errno = EINVAL; return -1;}
5021 #endif /* ndef _SC_SIGQUEUE_MAX */
5022         if (x == Mono_Posix_SysconfName__SC_SINGLE_PROCESS)
5023 #ifdef _SC_SINGLE_PROCESS
5024                 {*r = _SC_SINGLE_PROCESS; return 0;}
5025 #else /* def _SC_SINGLE_PROCESS */
5026                 {errno = EINVAL; return -1;}
5027 #endif /* ndef _SC_SINGLE_PROCESS */
5028         if (x == Mono_Posix_SysconfName__SC_SPAWN)
5029 #ifdef _SC_SPAWN
5030                 {*r = _SC_SPAWN; return 0;}
5031 #else /* def _SC_SPAWN */
5032                 {errno = EINVAL; return -1;}
5033 #endif /* ndef _SC_SPAWN */
5034         if (x == Mono_Posix_SysconfName__SC_SPIN_LOCKS)
5035 #ifdef _SC_SPIN_LOCKS
5036                 {*r = _SC_SPIN_LOCKS; return 0;}
5037 #else /* def _SC_SPIN_LOCKS */
5038                 {errno = EINVAL; return -1;}
5039 #endif /* ndef _SC_SPIN_LOCKS */
5040         if (x == Mono_Posix_SysconfName__SC_SPORADIC_SERVER)
5041 #ifdef _SC_SPORADIC_SERVER
5042                 {*r = _SC_SPORADIC_SERVER; return 0;}
5043 #else /* def _SC_SPORADIC_SERVER */
5044                 {errno = EINVAL; return -1;}
5045 #endif /* ndef _SC_SPORADIC_SERVER */
5046         if (x == Mono_Posix_SysconfName__SC_SSIZE_MAX)
5047 #ifdef _SC_SSIZE_MAX
5048                 {*r = _SC_SSIZE_MAX; return 0;}
5049 #else /* def _SC_SSIZE_MAX */
5050                 {errno = EINVAL; return -1;}
5051 #endif /* ndef _SC_SSIZE_MAX */
5052         if (x == Mono_Posix_SysconfName__SC_STREAMS)
5053 #ifdef _SC_STREAMS
5054                 {*r = _SC_STREAMS; return 0;}
5055 #else /* def _SC_STREAMS */
5056                 {errno = EINVAL; return -1;}
5057 #endif /* ndef _SC_STREAMS */
5058         if (x == Mono_Posix_SysconfName__SC_STREAM_MAX)
5059 #ifdef _SC_STREAM_MAX
5060                 {*r = _SC_STREAM_MAX; return 0;}
5061 #else /* def _SC_STREAM_MAX */
5062                 {errno = EINVAL; return -1;}
5063 #endif /* ndef _SC_STREAM_MAX */
5064         if (x == Mono_Posix_SysconfName__SC_SYMLOOP_MAX)
5065 #ifdef _SC_SYMLOOP_MAX
5066                 {*r = _SC_SYMLOOP_MAX; return 0;}
5067 #else /* def _SC_SYMLOOP_MAX */
5068                 {errno = EINVAL; return -1;}
5069 #endif /* ndef _SC_SYMLOOP_MAX */
5070         if (x == Mono_Posix_SysconfName__SC_SYNCHRONIZED_IO)
5071 #ifdef _SC_SYNCHRONIZED_IO
5072                 {*r = _SC_SYNCHRONIZED_IO; return 0;}
5073 #else /* def _SC_SYNCHRONIZED_IO */
5074                 {errno = EINVAL; return -1;}
5075 #endif /* ndef _SC_SYNCHRONIZED_IO */
5076         if (x == Mono_Posix_SysconfName__SC_SYSTEM_DATABASE)
5077 #ifdef _SC_SYSTEM_DATABASE
5078                 {*r = _SC_SYSTEM_DATABASE; return 0;}
5079 #else /* def _SC_SYSTEM_DATABASE */
5080                 {errno = EINVAL; return -1;}
5081 #endif /* ndef _SC_SYSTEM_DATABASE */
5082         if (x == Mono_Posix_SysconfName__SC_SYSTEM_DATABASE_R)
5083 #ifdef _SC_SYSTEM_DATABASE_R
5084                 {*r = _SC_SYSTEM_DATABASE_R; return 0;}
5085 #else /* def _SC_SYSTEM_DATABASE_R */
5086                 {errno = EINVAL; return -1;}
5087 #endif /* ndef _SC_SYSTEM_DATABASE_R */
5088         if (x == Mono_Posix_SysconfName__SC_THREADS)
5089 #ifdef _SC_THREADS
5090                 {*r = _SC_THREADS; return 0;}
5091 #else /* def _SC_THREADS */
5092                 {errno = EINVAL; return -1;}
5093 #endif /* ndef _SC_THREADS */
5094         if (x == Mono_Posix_SysconfName__SC_THREAD_ATTR_STACKADDR)
5095 #ifdef _SC_THREAD_ATTR_STACKADDR
5096                 {*r = _SC_THREAD_ATTR_STACKADDR; return 0;}
5097 #else /* def _SC_THREAD_ATTR_STACKADDR */
5098                 {errno = EINVAL; return -1;}
5099 #endif /* ndef _SC_THREAD_ATTR_STACKADDR */
5100         if (x == Mono_Posix_SysconfName__SC_THREAD_ATTR_STACKSIZE)
5101 #ifdef _SC_THREAD_ATTR_STACKSIZE
5102                 {*r = _SC_THREAD_ATTR_STACKSIZE; return 0;}
5103 #else /* def _SC_THREAD_ATTR_STACKSIZE */
5104                 {errno = EINVAL; return -1;}
5105 #endif /* ndef _SC_THREAD_ATTR_STACKSIZE */
5106         if (x == Mono_Posix_SysconfName__SC_THREAD_CPUTIME)
5107 #ifdef _SC_THREAD_CPUTIME
5108                 {*r = _SC_THREAD_CPUTIME; return 0;}
5109 #else /* def _SC_THREAD_CPUTIME */
5110                 {errno = EINVAL; return -1;}
5111 #endif /* ndef _SC_THREAD_CPUTIME */
5112         if (x == Mono_Posix_SysconfName__SC_THREAD_DESTRUCTOR_ITERATIONS)
5113 #ifdef _SC_THREAD_DESTRUCTOR_ITERATIONS
5114                 {*r = _SC_THREAD_DESTRUCTOR_ITERATIONS; return 0;}
5115 #else /* def _SC_THREAD_DESTRUCTOR_ITERATIONS */
5116                 {errno = EINVAL; return -1;}
5117 #endif /* ndef _SC_THREAD_DESTRUCTOR_ITERATIONS */
5118         if (x == Mono_Posix_SysconfName__SC_THREAD_KEYS_MAX)
5119 #ifdef _SC_THREAD_KEYS_MAX
5120                 {*r = _SC_THREAD_KEYS_MAX; return 0;}
5121 #else /* def _SC_THREAD_KEYS_MAX */
5122                 {errno = EINVAL; return -1;}
5123 #endif /* ndef _SC_THREAD_KEYS_MAX */
5124         if (x == Mono_Posix_SysconfName__SC_THREAD_PRIORITY_SCHEDULING)
5125 #ifdef _SC_THREAD_PRIORITY_SCHEDULING
5126                 {*r = _SC_THREAD_PRIORITY_SCHEDULING; return 0;}
5127 #else /* def _SC_THREAD_PRIORITY_SCHEDULING */
5128                 {errno = EINVAL; return -1;}
5129 #endif /* ndef _SC_THREAD_PRIORITY_SCHEDULING */
5130         if (x == Mono_Posix_SysconfName__SC_THREAD_PRIO_INHERIT)
5131 #ifdef _SC_THREAD_PRIO_INHERIT
5132                 {*r = _SC_THREAD_PRIO_INHERIT; return 0;}
5133 #else /* def _SC_THREAD_PRIO_INHERIT */
5134                 {errno = EINVAL; return -1;}
5135 #endif /* ndef _SC_THREAD_PRIO_INHERIT */
5136         if (x == Mono_Posix_SysconfName__SC_THREAD_PRIO_PROTECT)
5137 #ifdef _SC_THREAD_PRIO_PROTECT
5138                 {*r = _SC_THREAD_PRIO_PROTECT; return 0;}
5139 #else /* def _SC_THREAD_PRIO_PROTECT */
5140                 {errno = EINVAL; return -1;}
5141 #endif /* ndef _SC_THREAD_PRIO_PROTECT */
5142         if (x == Mono_Posix_SysconfName__SC_THREAD_PROCESS_SHARED)
5143 #ifdef _SC_THREAD_PROCESS_SHARED
5144                 {*r = _SC_THREAD_PROCESS_SHARED; return 0;}
5145 #else /* def _SC_THREAD_PROCESS_SHARED */
5146                 {errno = EINVAL; return -1;}
5147 #endif /* ndef _SC_THREAD_PROCESS_SHARED */
5148         if (x == Mono_Posix_SysconfName__SC_THREAD_SAFE_FUNCTIONS)
5149 #ifdef _SC_THREAD_SAFE_FUNCTIONS
5150                 {*r = _SC_THREAD_SAFE_FUNCTIONS; return 0;}
5151 #else /* def _SC_THREAD_SAFE_FUNCTIONS */
5152                 {errno = EINVAL; return -1;}
5153 #endif /* ndef _SC_THREAD_SAFE_FUNCTIONS */
5154         if (x == Mono_Posix_SysconfName__SC_THREAD_SPORADIC_SERVER)
5155 #ifdef _SC_THREAD_SPORADIC_SERVER
5156                 {*r = _SC_THREAD_SPORADIC_SERVER; return 0;}
5157 #else /* def _SC_THREAD_SPORADIC_SERVER */
5158                 {errno = EINVAL; return -1;}
5159 #endif /* ndef _SC_THREAD_SPORADIC_SERVER */
5160         if (x == Mono_Posix_SysconfName__SC_THREAD_STACK_MIN)
5161 #ifdef _SC_THREAD_STACK_MIN
5162                 {*r = _SC_THREAD_STACK_MIN; return 0;}
5163 #else /* def _SC_THREAD_STACK_MIN */
5164                 {errno = EINVAL; return -1;}
5165 #endif /* ndef _SC_THREAD_STACK_MIN */
5166         if (x == Mono_Posix_SysconfName__SC_THREAD_THREADS_MAX)
5167 #ifdef _SC_THREAD_THREADS_MAX
5168                 {*r = _SC_THREAD_THREADS_MAX; return 0;}
5169 #else /* def _SC_THREAD_THREADS_MAX */
5170                 {errno = EINVAL; return -1;}
5171 #endif /* ndef _SC_THREAD_THREADS_MAX */
5172         if (x == Mono_Posix_SysconfName__SC_TIMEOUTS)
5173 #ifdef _SC_TIMEOUTS
5174                 {*r = _SC_TIMEOUTS; return 0;}
5175 #else /* def _SC_TIMEOUTS */
5176                 {errno = EINVAL; return -1;}
5177 #endif /* ndef _SC_TIMEOUTS */
5178         if (x == Mono_Posix_SysconfName__SC_TIMERS)
5179 #ifdef _SC_TIMERS
5180                 {*r = _SC_TIMERS; return 0;}
5181 #else /* def _SC_TIMERS */
5182                 {errno = EINVAL; return -1;}
5183 #endif /* ndef _SC_TIMERS */
5184         if (x == Mono_Posix_SysconfName__SC_TIMER_MAX)
5185 #ifdef _SC_TIMER_MAX
5186                 {*r = _SC_TIMER_MAX; return 0;}
5187 #else /* def _SC_TIMER_MAX */
5188                 {errno = EINVAL; return -1;}
5189 #endif /* ndef _SC_TIMER_MAX */
5190         if (x == Mono_Posix_SysconfName__SC_TRACE)
5191 #ifdef _SC_TRACE
5192                 {*r = _SC_TRACE; return 0;}
5193 #else /* def _SC_TRACE */
5194                 {errno = EINVAL; return -1;}
5195 #endif /* ndef _SC_TRACE */
5196         if (x == Mono_Posix_SysconfName__SC_TRACE_EVENT_FILTER)
5197 #ifdef _SC_TRACE_EVENT_FILTER
5198                 {*r = _SC_TRACE_EVENT_FILTER; return 0;}
5199 #else /* def _SC_TRACE_EVENT_FILTER */
5200                 {errno = EINVAL; return -1;}
5201 #endif /* ndef _SC_TRACE_EVENT_FILTER */
5202         if (x == Mono_Posix_SysconfName__SC_TRACE_INHERIT)
5203 #ifdef _SC_TRACE_INHERIT
5204                 {*r = _SC_TRACE_INHERIT; return 0;}
5205 #else /* def _SC_TRACE_INHERIT */
5206                 {errno = EINVAL; return -1;}
5207 #endif /* ndef _SC_TRACE_INHERIT */
5208         if (x == Mono_Posix_SysconfName__SC_TRACE_LOG)
5209 #ifdef _SC_TRACE_LOG
5210                 {*r = _SC_TRACE_LOG; return 0;}
5211 #else /* def _SC_TRACE_LOG */
5212                 {errno = EINVAL; return -1;}
5213 #endif /* ndef _SC_TRACE_LOG */
5214         if (x == Mono_Posix_SysconfName__SC_TTY_NAME_MAX)
5215 #ifdef _SC_TTY_NAME_MAX
5216                 {*r = _SC_TTY_NAME_MAX; return 0;}
5217 #else /* def _SC_TTY_NAME_MAX */
5218                 {errno = EINVAL; return -1;}
5219 #endif /* ndef _SC_TTY_NAME_MAX */
5220         if (x == Mono_Posix_SysconfName__SC_TYPED_MEMORY_OBJECTS)
5221 #ifdef _SC_TYPED_MEMORY_OBJECTS
5222                 {*r = _SC_TYPED_MEMORY_OBJECTS; return 0;}
5223 #else /* def _SC_TYPED_MEMORY_OBJECTS */
5224                 {errno = EINVAL; return -1;}
5225 #endif /* ndef _SC_TYPED_MEMORY_OBJECTS */
5226         if (x == Mono_Posix_SysconfName__SC_TZNAME_MAX)
5227 #ifdef _SC_TZNAME_MAX
5228                 {*r = _SC_TZNAME_MAX; return 0;}
5229 #else /* def _SC_TZNAME_MAX */
5230                 {errno = EINVAL; return -1;}
5231 #endif /* ndef _SC_TZNAME_MAX */
5232         if (x == Mono_Posix_SysconfName__SC_T_IOV_MAX)
5233 #ifdef _SC_T_IOV_MAX
5234                 {*r = _SC_T_IOV_MAX; return 0;}
5235 #else /* def _SC_T_IOV_MAX */
5236                 {errno = EINVAL; return -1;}
5237 #endif /* ndef _SC_T_IOV_MAX */
5238         if (x == Mono_Posix_SysconfName__SC_UCHAR_MAX)
5239 #ifdef _SC_UCHAR_MAX
5240                 {*r = _SC_UCHAR_MAX; return 0;}
5241 #else /* def _SC_UCHAR_MAX */
5242                 {errno = EINVAL; return -1;}
5243 #endif /* ndef _SC_UCHAR_MAX */
5244         if (x == Mono_Posix_SysconfName__SC_UINT_MAX)
5245 #ifdef _SC_UINT_MAX
5246                 {*r = _SC_UINT_MAX; return 0;}
5247 #else /* def _SC_UINT_MAX */
5248                 {errno = EINVAL; return -1;}
5249 #endif /* ndef _SC_UINT_MAX */
5250         if (x == Mono_Posix_SysconfName__SC_UIO_MAXIOV)
5251 #ifdef _SC_UIO_MAXIOV
5252                 {*r = _SC_UIO_MAXIOV; return 0;}
5253 #else /* def _SC_UIO_MAXIOV */
5254                 {errno = EINVAL; return -1;}
5255 #endif /* ndef _SC_UIO_MAXIOV */
5256         if (x == Mono_Posix_SysconfName__SC_ULONG_MAX)
5257 #ifdef _SC_ULONG_MAX
5258                 {*r = _SC_ULONG_MAX; return 0;}
5259 #else /* def _SC_ULONG_MAX */
5260                 {errno = EINVAL; return -1;}
5261 #endif /* ndef _SC_ULONG_MAX */
5262         if (x == Mono_Posix_SysconfName__SC_USER_GROUPS)
5263 #ifdef _SC_USER_GROUPS
5264                 {*r = _SC_USER_GROUPS; return 0;}
5265 #else /* def _SC_USER_GROUPS */
5266                 {errno = EINVAL; return -1;}
5267 #endif /* ndef _SC_USER_GROUPS */
5268         if (x == Mono_Posix_SysconfName__SC_USER_GROUPS_R)
5269 #ifdef _SC_USER_GROUPS_R
5270                 {*r = _SC_USER_GROUPS_R; return 0;}
5271 #else /* def _SC_USER_GROUPS_R */
5272                 {errno = EINVAL; return -1;}
5273 #endif /* ndef _SC_USER_GROUPS_R */
5274         if (x == Mono_Posix_SysconfName__SC_USHRT_MAX)
5275 #ifdef _SC_USHRT_MAX
5276                 {*r = _SC_USHRT_MAX; return 0;}
5277 #else /* def _SC_USHRT_MAX */
5278                 {errno = EINVAL; return -1;}
5279 #endif /* ndef _SC_USHRT_MAX */
5280         if (x == Mono_Posix_SysconfName__SC_V6_ILP32_OFF32)
5281 #ifdef _SC_V6_ILP32_OFF32
5282                 {*r = _SC_V6_ILP32_OFF32; return 0;}
5283 #else /* def _SC_V6_ILP32_OFF32 */
5284                 {errno = EINVAL; return -1;}
5285 #endif /* ndef _SC_V6_ILP32_OFF32 */
5286         if (x == Mono_Posix_SysconfName__SC_V6_ILP32_OFFBIG)
5287 #ifdef _SC_V6_ILP32_OFFBIG
5288                 {*r = _SC_V6_ILP32_OFFBIG; return 0;}
5289 #else /* def _SC_V6_ILP32_OFFBIG */
5290                 {errno = EINVAL; return -1;}
5291 #endif /* ndef _SC_V6_ILP32_OFFBIG */
5292         if (x == Mono_Posix_SysconfName__SC_V6_LP64_OFF64)
5293 #ifdef _SC_V6_LP64_OFF64
5294                 {*r = _SC_V6_LP64_OFF64; return 0;}
5295 #else /* def _SC_V6_LP64_OFF64 */
5296                 {errno = EINVAL; return -1;}
5297 #endif /* ndef _SC_V6_LP64_OFF64 */
5298         if (x == Mono_Posix_SysconfName__SC_V6_LPBIG_OFFBIG)
5299 #ifdef _SC_V6_LPBIG_OFFBIG
5300                 {*r = _SC_V6_LPBIG_OFFBIG; return 0;}
5301 #else /* def _SC_V6_LPBIG_OFFBIG */
5302                 {errno = EINVAL; return -1;}
5303 #endif /* ndef _SC_V6_LPBIG_OFFBIG */
5304         if (x == Mono_Posix_SysconfName__SC_VERSION)
5305 #ifdef _SC_VERSION
5306                 {*r = _SC_VERSION; return 0;}
5307 #else /* def _SC_VERSION */
5308                 {errno = EINVAL; return -1;}
5309 #endif /* ndef _SC_VERSION */
5310         if (x == Mono_Posix_SysconfName__SC_WORD_BIT)
5311 #ifdef _SC_WORD_BIT
5312                 {*r = _SC_WORD_BIT; return 0;}
5313 #else /* def _SC_WORD_BIT */
5314                 {errno = EINVAL; return -1;}
5315 #endif /* ndef _SC_WORD_BIT */
5316         if (x == Mono_Posix_SysconfName__SC_XBS5_ILP32_OFF32)
5317 #ifdef _SC_XBS5_ILP32_OFF32
5318                 {*r = _SC_XBS5_ILP32_OFF32; return 0;}
5319 #else /* def _SC_XBS5_ILP32_OFF32 */
5320                 {errno = EINVAL; return -1;}
5321 #endif /* ndef _SC_XBS5_ILP32_OFF32 */
5322         if (x == Mono_Posix_SysconfName__SC_XBS5_ILP32_OFFBIG)
5323 #ifdef _SC_XBS5_ILP32_OFFBIG
5324                 {*r = _SC_XBS5_ILP32_OFFBIG; return 0;}
5325 #else /* def _SC_XBS5_ILP32_OFFBIG */
5326                 {errno = EINVAL; return -1;}
5327 #endif /* ndef _SC_XBS5_ILP32_OFFBIG */
5328         if (x == Mono_Posix_SysconfName__SC_XBS5_LP64_OFF64)
5329 #ifdef _SC_XBS5_LP64_OFF64
5330                 {*r = _SC_XBS5_LP64_OFF64; return 0;}
5331 #else /* def _SC_XBS5_LP64_OFF64 */
5332                 {errno = EINVAL; return -1;}
5333 #endif /* ndef _SC_XBS5_LP64_OFF64 */
5334         if (x == Mono_Posix_SysconfName__SC_XBS5_LPBIG_OFFBIG)
5335 #ifdef _SC_XBS5_LPBIG_OFFBIG
5336                 {*r = _SC_XBS5_LPBIG_OFFBIG; return 0;}
5337 #else /* def _SC_XBS5_LPBIG_OFFBIG */
5338                 {errno = EINVAL; return -1;}
5339 #endif /* ndef _SC_XBS5_LPBIG_OFFBIG */
5340         if (x == Mono_Posix_SysconfName__SC_XOPEN_CRYPT)
5341 #ifdef _SC_XOPEN_CRYPT
5342                 {*r = _SC_XOPEN_CRYPT; return 0;}
5343 #else /* def _SC_XOPEN_CRYPT */
5344                 {errno = EINVAL; return -1;}
5345 #endif /* ndef _SC_XOPEN_CRYPT */
5346         if (x == Mono_Posix_SysconfName__SC_XOPEN_ENH_I18N)
5347 #ifdef _SC_XOPEN_ENH_I18N
5348                 {*r = _SC_XOPEN_ENH_I18N; return 0;}
5349 #else /* def _SC_XOPEN_ENH_I18N */
5350                 {errno = EINVAL; return -1;}
5351 #endif /* ndef _SC_XOPEN_ENH_I18N */
5352         if (x == Mono_Posix_SysconfName__SC_XOPEN_LEGACY)
5353 #ifdef _SC_XOPEN_LEGACY
5354                 {*r = _SC_XOPEN_LEGACY; return 0;}
5355 #else /* def _SC_XOPEN_LEGACY */
5356                 {errno = EINVAL; return -1;}
5357 #endif /* ndef _SC_XOPEN_LEGACY */
5358         if (x == Mono_Posix_SysconfName__SC_XOPEN_REALTIME)
5359 #ifdef _SC_XOPEN_REALTIME
5360                 {*r = _SC_XOPEN_REALTIME; return 0;}
5361 #else /* def _SC_XOPEN_REALTIME */
5362                 {errno = EINVAL; return -1;}
5363 #endif /* ndef _SC_XOPEN_REALTIME */
5364         if (x == Mono_Posix_SysconfName__SC_XOPEN_REALTIME_THREADS)
5365 #ifdef _SC_XOPEN_REALTIME_THREADS
5366                 {*r = _SC_XOPEN_REALTIME_THREADS; return 0;}
5367 #else /* def _SC_XOPEN_REALTIME_THREADS */
5368                 {errno = EINVAL; return -1;}
5369 #endif /* ndef _SC_XOPEN_REALTIME_THREADS */
5370         if (x == Mono_Posix_SysconfName__SC_XOPEN_SHM)
5371 #ifdef _SC_XOPEN_SHM
5372                 {*r = _SC_XOPEN_SHM; return 0;}
5373 #else /* def _SC_XOPEN_SHM */
5374                 {errno = EINVAL; return -1;}
5375 #endif /* ndef _SC_XOPEN_SHM */
5376         if (x == Mono_Posix_SysconfName__SC_XOPEN_UNIX)
5377 #ifdef _SC_XOPEN_UNIX
5378                 {*r = _SC_XOPEN_UNIX; return 0;}
5379 #else /* def _SC_XOPEN_UNIX */
5380                 {errno = EINVAL; return -1;}
5381 #endif /* ndef _SC_XOPEN_UNIX */
5382         if (x == Mono_Posix_SysconfName__SC_XOPEN_VERSION)
5383 #ifdef _SC_XOPEN_VERSION
5384                 {*r = _SC_XOPEN_VERSION; return 0;}
5385 #else /* def _SC_XOPEN_VERSION */
5386                 {errno = EINVAL; return -1;}
5387 #endif /* ndef _SC_XOPEN_VERSION */
5388         if (x == Mono_Posix_SysconfName__SC_XOPEN_XCU_VERSION)
5389 #ifdef _SC_XOPEN_XCU_VERSION
5390                 {*r = _SC_XOPEN_XCU_VERSION; return 0;}
5391 #else /* def _SC_XOPEN_XCU_VERSION */
5392                 {errno = EINVAL; return -1;}
5393 #endif /* ndef _SC_XOPEN_XCU_VERSION */
5394         if (x == Mono_Posix_SysconfName__SC_XOPEN_XPG2)
5395 #ifdef _SC_XOPEN_XPG2
5396                 {*r = _SC_XOPEN_XPG2; return 0;}
5397 #else /* def _SC_XOPEN_XPG2 */
5398                 {errno = EINVAL; return -1;}
5399 #endif /* ndef _SC_XOPEN_XPG2 */
5400         if (x == Mono_Posix_SysconfName__SC_XOPEN_XPG3)
5401 #ifdef _SC_XOPEN_XPG3
5402                 {*r = _SC_XOPEN_XPG3; return 0;}
5403 #else /* def _SC_XOPEN_XPG3 */
5404                 {errno = EINVAL; return -1;}
5405 #endif /* ndef _SC_XOPEN_XPG3 */
5406         if (x == Mono_Posix_SysconfName__SC_XOPEN_XPG4)
5407 #ifdef _SC_XOPEN_XPG4
5408                 {*r = _SC_XOPEN_XPG4; return 0;}
5409 #else /* def _SC_XOPEN_XPG4 */
5410                 {errno = EINVAL; return -1;}
5411 #endif /* ndef _SC_XOPEN_XPG4 */
5412         if (x == 0)
5413                 return 0;
5414         errno = EINVAL; return -1;
5415 }
5416
5417 int Mono_Posix_ToSysconfName (int x, int *r)
5418 {
5419         *r = 0;
5420         if (x == 0)
5421                 return 0;
5422 #ifdef _SC_2_CHAR_TERM
5423         if (x == _SC_2_CHAR_TERM)
5424                 {*r = Mono_Posix_SysconfName__SC_2_CHAR_TERM; return 0;}
5425 #endif /* ndef _SC_2_CHAR_TERM */
5426 #ifdef _SC_2_C_BIND
5427         if (x == _SC_2_C_BIND)
5428                 {*r = Mono_Posix_SysconfName__SC_2_C_BIND; return 0;}
5429 #endif /* ndef _SC_2_C_BIND */
5430 #ifdef _SC_2_C_DEV
5431         if (x == _SC_2_C_DEV)
5432                 {*r = Mono_Posix_SysconfName__SC_2_C_DEV; return 0;}
5433 #endif /* ndef _SC_2_C_DEV */
5434 #ifdef _SC_2_C_VERSION
5435         if (x == _SC_2_C_VERSION)
5436                 {*r = Mono_Posix_SysconfName__SC_2_C_VERSION; return 0;}
5437 #endif /* ndef _SC_2_C_VERSION */
5438 #ifdef _SC_2_FORT_DEV
5439         if (x == _SC_2_FORT_DEV)
5440                 {*r = Mono_Posix_SysconfName__SC_2_FORT_DEV; return 0;}
5441 #endif /* ndef _SC_2_FORT_DEV */
5442 #ifdef _SC_2_FORT_RUN
5443         if (x == _SC_2_FORT_RUN)
5444                 {*r = Mono_Posix_SysconfName__SC_2_FORT_RUN; return 0;}
5445 #endif /* ndef _SC_2_FORT_RUN */
5446 #ifdef _SC_2_LOCALEDEF
5447         if (x == _SC_2_LOCALEDEF)
5448                 {*r = Mono_Posix_SysconfName__SC_2_LOCALEDEF; return 0;}
5449 #endif /* ndef _SC_2_LOCALEDEF */
5450 #ifdef _SC_2_PBS
5451         if (x == _SC_2_PBS)
5452                 {*r = Mono_Posix_SysconfName__SC_2_PBS; return 0;}
5453 #endif /* ndef _SC_2_PBS */
5454 #ifdef _SC_2_PBS_ACCOUNTING
5455         if (x == _SC_2_PBS_ACCOUNTING)
5456                 {*r = Mono_Posix_SysconfName__SC_2_PBS_ACCOUNTING; return 0;}
5457 #endif /* ndef _SC_2_PBS_ACCOUNTING */
5458 #ifdef _SC_2_PBS_CHECKPOINT
5459         if (x == _SC_2_PBS_CHECKPOINT)
5460                 {*r = Mono_Posix_SysconfName__SC_2_PBS_CHECKPOINT; return 0;}
5461 #endif /* ndef _SC_2_PBS_CHECKPOINT */
5462 #ifdef _SC_2_PBS_LOCATE
5463         if (x == _SC_2_PBS_LOCATE)
5464                 {*r = Mono_Posix_SysconfName__SC_2_PBS_LOCATE; return 0;}
5465 #endif /* ndef _SC_2_PBS_LOCATE */
5466 #ifdef _SC_2_PBS_MESSAGE
5467         if (x == _SC_2_PBS_MESSAGE)
5468                 {*r = Mono_Posix_SysconfName__SC_2_PBS_MESSAGE; return 0;}
5469 #endif /* ndef _SC_2_PBS_MESSAGE */
5470 #ifdef _SC_2_PBS_TRACK
5471         if (x == _SC_2_PBS_TRACK)
5472                 {*r = Mono_Posix_SysconfName__SC_2_PBS_TRACK; return 0;}
5473 #endif /* ndef _SC_2_PBS_TRACK */
5474 #ifdef _SC_2_SW_DEV
5475         if (x == _SC_2_SW_DEV)
5476                 {*r = Mono_Posix_SysconfName__SC_2_SW_DEV; return 0;}
5477 #endif /* ndef _SC_2_SW_DEV */
5478 #ifdef _SC_2_UPE
5479         if (x == _SC_2_UPE)
5480                 {*r = Mono_Posix_SysconfName__SC_2_UPE; return 0;}
5481 #endif /* ndef _SC_2_UPE */
5482 #ifdef _SC_2_VERSION
5483         if (x == _SC_2_VERSION)
5484                 {*r = Mono_Posix_SysconfName__SC_2_VERSION; return 0;}
5485 #endif /* ndef _SC_2_VERSION */
5486 #ifdef _SC_ADVISORY_INFO
5487         if (x == _SC_ADVISORY_INFO)
5488                 {*r = Mono_Posix_SysconfName__SC_ADVISORY_INFO; return 0;}
5489 #endif /* ndef _SC_ADVISORY_INFO */
5490 #ifdef _SC_AIO_LISTIO_MAX
5491         if (x == _SC_AIO_LISTIO_MAX)
5492                 {*r = Mono_Posix_SysconfName__SC_AIO_LISTIO_MAX; return 0;}
5493 #endif /* ndef _SC_AIO_LISTIO_MAX */
5494 #ifdef _SC_AIO_MAX
5495         if (x == _SC_AIO_MAX)
5496                 {*r = Mono_Posix_SysconfName__SC_AIO_MAX; return 0;}
5497 #endif /* ndef _SC_AIO_MAX */
5498 #ifdef _SC_AIO_PRIO_DELTA_MAX
5499         if (x == _SC_AIO_PRIO_DELTA_MAX)
5500                 {*r = Mono_Posix_SysconfName__SC_AIO_PRIO_DELTA_MAX; return 0;}
5501 #endif /* ndef _SC_AIO_PRIO_DELTA_MAX */
5502 #ifdef _SC_ARG_MAX
5503         if (x == _SC_ARG_MAX)
5504                 {*r = Mono_Posix_SysconfName__SC_ARG_MAX; return 0;}
5505 #endif /* ndef _SC_ARG_MAX */
5506 #ifdef _SC_ASYNCHRONOUS_IO
5507         if (x == _SC_ASYNCHRONOUS_IO)
5508                 {*r = Mono_Posix_SysconfName__SC_ASYNCHRONOUS_IO; return 0;}
5509 #endif /* ndef _SC_ASYNCHRONOUS_IO */
5510 #ifdef _SC_ATEXIT_MAX
5511         if (x == _SC_ATEXIT_MAX)
5512                 {*r = Mono_Posix_SysconfName__SC_ATEXIT_MAX; return 0;}
5513 #endif /* ndef _SC_ATEXIT_MAX */
5514 #ifdef _SC_AVPHYS_PAGES
5515         if (x == _SC_AVPHYS_PAGES)
5516                 {*r = Mono_Posix_SysconfName__SC_AVPHYS_PAGES; return 0;}
5517 #endif /* ndef _SC_AVPHYS_PAGES */
5518 #ifdef _SC_BARRIERS
5519         if (x == _SC_BARRIERS)
5520                 {*r = Mono_Posix_SysconfName__SC_BARRIERS; return 0;}
5521 #endif /* ndef _SC_BARRIERS */
5522 #ifdef _SC_BASE
5523         if (x == _SC_BASE)
5524                 {*r = Mono_Posix_SysconfName__SC_BASE; return 0;}
5525 #endif /* ndef _SC_BASE */
5526 #ifdef _SC_BC_BASE_MAX
5527         if (x == _SC_BC_BASE_MAX)
5528                 {*r = Mono_Posix_SysconfName__SC_BC_BASE_MAX; return 0;}
5529 #endif /* ndef _SC_BC_BASE_MAX */
5530 #ifdef _SC_BC_DIM_MAX
5531         if (x == _SC_BC_DIM_MAX)
5532                 {*r = Mono_Posix_SysconfName__SC_BC_DIM_MAX; return 0;}
5533 #endif /* ndef _SC_BC_DIM_MAX */
5534 #ifdef _SC_BC_SCALE_MAX
5535         if (x == _SC_BC_SCALE_MAX)
5536                 {*r = Mono_Posix_SysconfName__SC_BC_SCALE_MAX; return 0;}
5537 #endif /* ndef _SC_BC_SCALE_MAX */
5538 #ifdef _SC_BC_STRING_MAX
5539         if (x == _SC_BC_STRING_MAX)
5540                 {*r = Mono_Posix_SysconfName__SC_BC_STRING_MAX; return 0;}
5541 #endif /* ndef _SC_BC_STRING_MAX */
5542 #ifdef _SC_CHARCLASS_NAME_MAX
5543         if (x == _SC_CHARCLASS_NAME_MAX)
5544                 {*r = Mono_Posix_SysconfName__SC_CHARCLASS_NAME_MAX; return 0;}
5545 #endif /* ndef _SC_CHARCLASS_NAME_MAX */
5546 #ifdef _SC_CHAR_BIT
5547         if (x == _SC_CHAR_BIT)
5548                 {*r = Mono_Posix_SysconfName__SC_CHAR_BIT; return 0;}
5549 #endif /* ndef _SC_CHAR_BIT */
5550 #ifdef _SC_CHAR_MAX
5551         if (x == _SC_CHAR_MAX)
5552                 {*r = Mono_Posix_SysconfName__SC_CHAR_MAX; return 0;}
5553 #endif /* ndef _SC_CHAR_MAX */
5554 #ifdef _SC_CHAR_MIN
5555         if (x == _SC_CHAR_MIN)
5556                 {*r = Mono_Posix_SysconfName__SC_CHAR_MIN; return 0;}
5557 #endif /* ndef _SC_CHAR_MIN */
5558 #ifdef _SC_CHILD_MAX
5559         if (x == _SC_CHILD_MAX)
5560                 {*r = Mono_Posix_SysconfName__SC_CHILD_MAX; return 0;}
5561 #endif /* ndef _SC_CHILD_MAX */
5562 #ifdef _SC_CLK_TCK
5563         if (x == _SC_CLK_TCK)
5564                 {*r = Mono_Posix_SysconfName__SC_CLK_TCK; return 0;}
5565 #endif /* ndef _SC_CLK_TCK */
5566 #ifdef _SC_CLOCK_SELECTION
5567         if (x == _SC_CLOCK_SELECTION)
5568                 {*r = Mono_Posix_SysconfName__SC_CLOCK_SELECTION; return 0;}
5569 #endif /* ndef _SC_CLOCK_SELECTION */
5570 #ifdef _SC_COLL_WEIGHTS_MAX
5571         if (x == _SC_COLL_WEIGHTS_MAX)
5572                 {*r = Mono_Posix_SysconfName__SC_COLL_WEIGHTS_MAX; return 0;}
5573 #endif /* ndef _SC_COLL_WEIGHTS_MAX */
5574 #ifdef _SC_CPUTIME
5575         if (x == _SC_CPUTIME)
5576                 {*r = Mono_Posix_SysconfName__SC_CPUTIME; return 0;}
5577 #endif /* ndef _SC_CPUTIME */
5578 #ifdef _SC_C_LANG_SUPPORT
5579         if (x == _SC_C_LANG_SUPPORT)
5580                 {*r = Mono_Posix_SysconfName__SC_C_LANG_SUPPORT; return 0;}
5581 #endif /* ndef _SC_C_LANG_SUPPORT */
5582 #ifdef _SC_C_LANG_SUPPORT_R
5583         if (x == _SC_C_LANG_SUPPORT_R)
5584                 {*r = Mono_Posix_SysconfName__SC_C_LANG_SUPPORT_R; return 0;}
5585 #endif /* ndef _SC_C_LANG_SUPPORT_R */
5586 #ifdef _SC_DELAYTIMER_MAX
5587         if (x == _SC_DELAYTIMER_MAX)
5588                 {*r = Mono_Posix_SysconfName__SC_DELAYTIMER_MAX; return 0;}
5589 #endif /* ndef _SC_DELAYTIMER_MAX */
5590 #ifdef _SC_DEVICE_IO
5591         if (x == _SC_DEVICE_IO)
5592                 {*r = Mono_Posix_SysconfName__SC_DEVICE_IO; return 0;}
5593 #endif /* ndef _SC_DEVICE_IO */
5594 #ifdef _SC_DEVICE_SPECIFIC
5595         if (x == _SC_DEVICE_SPECIFIC)
5596                 {*r = Mono_Posix_SysconfName__SC_DEVICE_SPECIFIC; return 0;}
5597 #endif /* ndef _SC_DEVICE_SPECIFIC */
5598 #ifdef _SC_DEVICE_SPECIFIC_R
5599         if (x == _SC_DEVICE_SPECIFIC_R)
5600                 {*r = Mono_Posix_SysconfName__SC_DEVICE_SPECIFIC_R; return 0;}
5601 #endif /* ndef _SC_DEVICE_SPECIFIC_R */
5602 #ifdef _SC_EQUIV_CLASS_MAX
5603         if (x == _SC_EQUIV_CLASS_MAX)
5604                 {*r = Mono_Posix_SysconfName__SC_EQUIV_CLASS_MAX; return 0;}
5605 #endif /* ndef _SC_EQUIV_CLASS_MAX */
5606 #ifdef _SC_EXPR_NEST_MAX
5607         if (x == _SC_EXPR_NEST_MAX)
5608                 {*r = Mono_Posix_SysconfName__SC_EXPR_NEST_MAX; return 0;}
5609 #endif /* ndef _SC_EXPR_NEST_MAX */
5610 #ifdef _SC_FD_MGMT
5611         if (x == _SC_FD_MGMT)
5612                 {*r = Mono_Posix_SysconfName__SC_FD_MGMT; return 0;}
5613 #endif /* ndef _SC_FD_MGMT */
5614 #ifdef _SC_FIFO
5615         if (x == _SC_FIFO)
5616                 {*r = Mono_Posix_SysconfName__SC_FIFO; return 0;}
5617 #endif /* ndef _SC_FIFO */
5618 #ifdef _SC_FILE_ATTRIBUTES
5619         if (x == _SC_FILE_ATTRIBUTES)
5620                 {*r = Mono_Posix_SysconfName__SC_FILE_ATTRIBUTES; return 0;}
5621 #endif /* ndef _SC_FILE_ATTRIBUTES */
5622 #ifdef _SC_FILE_LOCKING
5623         if (x == _SC_FILE_LOCKING)
5624                 {*r = Mono_Posix_SysconfName__SC_FILE_LOCKING; return 0;}
5625 #endif /* ndef _SC_FILE_LOCKING */
5626 #ifdef _SC_FILE_SYSTEM
5627         if (x == _SC_FILE_SYSTEM)
5628                 {*r = Mono_Posix_SysconfName__SC_FILE_SYSTEM; return 0;}
5629 #endif /* ndef _SC_FILE_SYSTEM */
5630 #ifdef _SC_FSYNC
5631         if (x == _SC_FSYNC)
5632                 {*r = Mono_Posix_SysconfName__SC_FSYNC; return 0;}
5633 #endif /* ndef _SC_FSYNC */
5634 #ifdef _SC_GETGR_R_SIZE_MAX
5635         if (x == _SC_GETGR_R_SIZE_MAX)
5636                 {*r = Mono_Posix_SysconfName__SC_GETGR_R_SIZE_MAX; return 0;}
5637 #endif /* ndef _SC_GETGR_R_SIZE_MAX */
5638 #ifdef _SC_GETPW_R_SIZE_MAX
5639         if (x == _SC_GETPW_R_SIZE_MAX)
5640                 {*r = Mono_Posix_SysconfName__SC_GETPW_R_SIZE_MAX; return 0;}
5641 #endif /* ndef _SC_GETPW_R_SIZE_MAX */
5642 #ifdef _SC_HOST_NAME_MAX
5643         if (x == _SC_HOST_NAME_MAX)
5644                 {*r = Mono_Posix_SysconfName__SC_HOST_NAME_MAX; return 0;}
5645 #endif /* ndef _SC_HOST_NAME_MAX */
5646 #ifdef _SC_INT_MAX
5647         if (x == _SC_INT_MAX)
5648                 {*r = Mono_Posix_SysconfName__SC_INT_MAX; return 0;}
5649 #endif /* ndef _SC_INT_MAX */
5650 #ifdef _SC_INT_MIN
5651         if (x == _SC_INT_MIN)
5652                 {*r = Mono_Posix_SysconfName__SC_INT_MIN; return 0;}
5653 #endif /* ndef _SC_INT_MIN */
5654 #ifdef _SC_IOV_MAX
5655         if (x == _SC_IOV_MAX)
5656                 {*r = Mono_Posix_SysconfName__SC_IOV_MAX; return 0;}
5657 #endif /* ndef _SC_IOV_MAX */
5658 #ifdef _SC_JOB_CONTROL
5659         if (x == _SC_JOB_CONTROL)
5660                 {*r = Mono_Posix_SysconfName__SC_JOB_CONTROL; return 0;}
5661 #endif /* ndef _SC_JOB_CONTROL */
5662 #ifdef _SC_LEVEL1_DCACHE_ASSOC
5663         if (x == _SC_LEVEL1_DCACHE_ASSOC)
5664                 {*r = Mono_Posix_SysconfName__SC_LEVEL1_DCACHE_ASSOC; return 0;}
5665 #endif /* ndef _SC_LEVEL1_DCACHE_ASSOC */
5666 #ifdef _SC_LEVEL1_DCACHE_LINESIZE
5667         if (x == _SC_LEVEL1_DCACHE_LINESIZE)
5668                 {*r = Mono_Posix_SysconfName__SC_LEVEL1_DCACHE_LINESIZE; return 0;}
5669 #endif /* ndef _SC_LEVEL1_DCACHE_LINESIZE */
5670 #ifdef _SC_LEVEL1_DCACHE_SIZE
5671         if (x == _SC_LEVEL1_DCACHE_SIZE)
5672                 {*r = Mono_Posix_SysconfName__SC_LEVEL1_DCACHE_SIZE; return 0;}
5673 #endif /* ndef _SC_LEVEL1_DCACHE_SIZE */
5674 #ifdef _SC_LEVEL1_ICACHE_ASSOC
5675         if (x == _SC_LEVEL1_ICACHE_ASSOC)
5676                 {*r = Mono_Posix_SysconfName__SC_LEVEL1_ICACHE_ASSOC; return 0;}
5677 #endif /* ndef _SC_LEVEL1_ICACHE_ASSOC */
5678 #ifdef _SC_LEVEL1_ICACHE_LINESIZE
5679         if (x == _SC_LEVEL1_ICACHE_LINESIZE)
5680                 {*r = Mono_Posix_SysconfName__SC_LEVEL1_ICACHE_LINESIZE; return 0;}
5681 #endif /* ndef _SC_LEVEL1_ICACHE_LINESIZE */
5682 #ifdef _SC_LEVEL1_ICACHE_SIZE
5683         if (x == _SC_LEVEL1_ICACHE_SIZE)
5684                 {*r = Mono_Posix_SysconfName__SC_LEVEL1_ICACHE_SIZE; return 0;}
5685 #endif /* ndef _SC_LEVEL1_ICACHE_SIZE */
5686 #ifdef _SC_LEVEL2_CACHE_ASSOC
5687         if (x == _SC_LEVEL2_CACHE_ASSOC)
5688                 {*r = Mono_Posix_SysconfName__SC_LEVEL2_CACHE_ASSOC; return 0;}
5689 #endif /* ndef _SC_LEVEL2_CACHE_ASSOC */
5690 #ifdef _SC_LEVEL2_CACHE_LINESIZE
5691         if (x == _SC_LEVEL2_CACHE_LINESIZE)
5692                 {*r = Mono_Posix_SysconfName__SC_LEVEL2_CACHE_LINESIZE; return 0;}
5693 #endif /* ndef _SC_LEVEL2_CACHE_LINESIZE */
5694 #ifdef _SC_LEVEL2_CACHE_SIZE
5695         if (x == _SC_LEVEL2_CACHE_SIZE)
5696                 {*r = Mono_Posix_SysconfName__SC_LEVEL2_CACHE_SIZE; return 0;}
5697 #endif /* ndef _SC_LEVEL2_CACHE_SIZE */
5698 #ifdef _SC_LEVEL3_CACHE_ASSOC
5699         if (x == _SC_LEVEL3_CACHE_ASSOC)
5700                 {*r = Mono_Posix_SysconfName__SC_LEVEL3_CACHE_ASSOC; return 0;}
5701 #endif /* ndef _SC_LEVEL3_CACHE_ASSOC */
5702 #ifdef _SC_LEVEL3_CACHE_LINESIZE
5703         if (x == _SC_LEVEL3_CACHE_LINESIZE)
5704                 {*r = Mono_Posix_SysconfName__SC_LEVEL3_CACHE_LINESIZE; return 0;}
5705 #endif /* ndef _SC_LEVEL3_CACHE_LINESIZE */
5706 #ifdef _SC_LEVEL3_CACHE_SIZE
5707         if (x == _SC_LEVEL3_CACHE_SIZE)
5708                 {*r = Mono_Posix_SysconfName__SC_LEVEL3_CACHE_SIZE; return 0;}
5709 #endif /* ndef _SC_LEVEL3_CACHE_SIZE */
5710 #ifdef _SC_LEVEL4_CACHE_ASSOC
5711         if (x == _SC_LEVEL4_CACHE_ASSOC)
5712                 {*r = Mono_Posix_SysconfName__SC_LEVEL4_CACHE_ASSOC; return 0;}
5713 #endif /* ndef _SC_LEVEL4_CACHE_ASSOC */
5714 #ifdef _SC_LEVEL4_CACHE_LINESIZE
5715         if (x == _SC_LEVEL4_CACHE_LINESIZE)
5716                 {*r = Mono_Posix_SysconfName__SC_LEVEL4_CACHE_LINESIZE; return 0;}
5717 #endif /* ndef _SC_LEVEL4_CACHE_LINESIZE */
5718 #ifdef _SC_LEVEL4_CACHE_SIZE
5719         if (x == _SC_LEVEL4_CACHE_SIZE)
5720                 {*r = Mono_Posix_SysconfName__SC_LEVEL4_CACHE_SIZE; return 0;}
5721 #endif /* ndef _SC_LEVEL4_CACHE_SIZE */
5722 #ifdef _SC_LINE_MAX
5723         if (x == _SC_LINE_MAX)
5724                 {*r = Mono_Posix_SysconfName__SC_LINE_MAX; return 0;}
5725 #endif /* ndef _SC_LINE_MAX */
5726 #ifdef _SC_LOGIN_NAME_MAX
5727         if (x == _SC_LOGIN_NAME_MAX)
5728                 {*r = Mono_Posix_SysconfName__SC_LOGIN_NAME_MAX; return 0;}
5729 #endif /* ndef _SC_LOGIN_NAME_MAX */
5730 #ifdef _SC_LONG_BIT
5731         if (x == _SC_LONG_BIT)
5732                 {*r = Mono_Posix_SysconfName__SC_LONG_BIT; return 0;}
5733 #endif /* ndef _SC_LONG_BIT */
5734 #ifdef _SC_MAPPED_FILES
5735         if (x == _SC_MAPPED_FILES)
5736                 {*r = Mono_Posix_SysconfName__SC_MAPPED_FILES; return 0;}
5737 #endif /* ndef _SC_MAPPED_FILES */
5738 #ifdef _SC_MB_LEN_MAX
5739         if (x == _SC_MB_LEN_MAX)
5740                 {*r = Mono_Posix_SysconfName__SC_MB_LEN_MAX; return 0;}
5741 #endif /* ndef _SC_MB_LEN_MAX */
5742 #ifdef _SC_MEMLOCK
5743         if (x == _SC_MEMLOCK)
5744                 {*r = Mono_Posix_SysconfName__SC_MEMLOCK; return 0;}
5745 #endif /* ndef _SC_MEMLOCK */
5746 #ifdef _SC_MEMLOCK_RANGE
5747         if (x == _SC_MEMLOCK_RANGE)
5748                 {*r = Mono_Posix_SysconfName__SC_MEMLOCK_RANGE; return 0;}
5749 #endif /* ndef _SC_MEMLOCK_RANGE */
5750 #ifdef _SC_MEMORY_PROTECTION
5751         if (x == _SC_MEMORY_PROTECTION)
5752                 {*r = Mono_Posix_SysconfName__SC_MEMORY_PROTECTION; return 0;}
5753 #endif /* ndef _SC_MEMORY_PROTECTION */
5754 #ifdef _SC_MESSAGE_PASSING
5755         if (x == _SC_MESSAGE_PASSING)
5756                 {*r = Mono_Posix_SysconfName__SC_MESSAGE_PASSING; return 0;}
5757 #endif /* ndef _SC_MESSAGE_PASSING */
5758 #ifdef _SC_MONOTONIC_CLOCK
5759         if (x == _SC_MONOTONIC_CLOCK)
5760                 {*r = Mono_Posix_SysconfName__SC_MONOTONIC_CLOCK; return 0;}
5761 #endif /* ndef _SC_MONOTONIC_CLOCK */
5762 #ifdef _SC_MQ_OPEN_MAX
5763         if (x == _SC_MQ_OPEN_MAX)
5764                 {*r = Mono_Posix_SysconfName__SC_MQ_OPEN_MAX; return 0;}
5765 #endif /* ndef _SC_MQ_OPEN_MAX */
5766 #ifdef _SC_MQ_PRIO_MAX
5767         if (x == _SC_MQ_PRIO_MAX)
5768                 {*r = Mono_Posix_SysconfName__SC_MQ_PRIO_MAX; return 0;}
5769 #endif /* ndef _SC_MQ_PRIO_MAX */
5770 #ifdef _SC_MULTI_PROCESS
5771         if (x == _SC_MULTI_PROCESS)
5772                 {*r = Mono_Posix_SysconfName__SC_MULTI_PROCESS; return 0;}
5773 #endif /* ndef _SC_MULTI_PROCESS */
5774 #ifdef _SC_NETWORKING
5775         if (x == _SC_NETWORKING)
5776                 {*r = Mono_Posix_SysconfName__SC_NETWORKING; return 0;}
5777 #endif /* ndef _SC_NETWORKING */
5778 #ifdef _SC_NGROUPS_MAX
5779         if (x == _SC_NGROUPS_MAX)
5780                 {*r = Mono_Posix_SysconfName__SC_NGROUPS_MAX; return 0;}
5781 #endif /* ndef _SC_NGROUPS_MAX */
5782 #ifdef _SC_NL_ARGMAX
5783         if (x == _SC_NL_ARGMAX)
5784                 {*r = Mono_Posix_SysconfName__SC_NL_ARGMAX; return 0;}
5785 #endif /* ndef _SC_NL_ARGMAX */
5786 #ifdef _SC_NL_LANGMAX
5787         if (x == _SC_NL_LANGMAX)
5788                 {*r = Mono_Posix_SysconfName__SC_NL_LANGMAX; return 0;}
5789 #endif /* ndef _SC_NL_LANGMAX */
5790 #ifdef _SC_NL_MSGMAX
5791         if (x == _SC_NL_MSGMAX)
5792                 {*r = Mono_Posix_SysconfName__SC_NL_MSGMAX; return 0;}
5793 #endif /* ndef _SC_NL_MSGMAX */
5794 #ifdef _SC_NL_NMAX
5795         if (x == _SC_NL_NMAX)
5796                 {*r = Mono_Posix_SysconfName__SC_NL_NMAX; return 0;}
5797 #endif /* ndef _SC_NL_NMAX */
5798 #ifdef _SC_NL_SETMAX
5799         if (x == _SC_NL_SETMAX)
5800                 {*r = Mono_Posix_SysconfName__SC_NL_SETMAX; return 0;}
5801 #endif /* ndef _SC_NL_SETMAX */
5802 #ifdef _SC_NL_TEXTMAX
5803         if (x == _SC_NL_TEXTMAX)
5804                 {*r = Mono_Posix_SysconfName__SC_NL_TEXTMAX; return 0;}
5805 #endif /* ndef _SC_NL_TEXTMAX */
5806 #ifdef _SC_NPROCESSORS_CONF
5807         if (x == _SC_NPROCESSORS_CONF)
5808                 {*r = Mono_Posix_SysconfName__SC_NPROCESSORS_CONF; return 0;}
5809 #endif /* ndef _SC_NPROCESSORS_CONF */
5810 #ifdef _SC_NPROCESSORS_ONLN
5811         if (x == _SC_NPROCESSORS_ONLN)
5812                 {*r = Mono_Posix_SysconfName__SC_NPROCESSORS_ONLN; return 0;}
5813 #endif /* ndef _SC_NPROCESSORS_ONLN */
5814 #ifdef _SC_NZERO
5815         if (x == _SC_NZERO)
5816                 {*r = Mono_Posix_SysconfName__SC_NZERO; return 0;}
5817 #endif /* ndef _SC_NZERO */
5818 #ifdef _SC_OPEN_MAX
5819         if (x == _SC_OPEN_MAX)
5820                 {*r = Mono_Posix_SysconfName__SC_OPEN_MAX; return 0;}
5821 #endif /* ndef _SC_OPEN_MAX */
5822 #ifdef _SC_PAGESIZE
5823         if (x == _SC_PAGESIZE)
5824                 {*r = Mono_Posix_SysconfName__SC_PAGESIZE; return 0;}
5825 #endif /* ndef _SC_PAGESIZE */
5826 #ifdef _SC_PASS_MAX
5827         if (x == _SC_PASS_MAX)
5828                 {*r = Mono_Posix_SysconfName__SC_PASS_MAX; return 0;}
5829 #endif /* ndef _SC_PASS_MAX */
5830 #ifdef _SC_PHYS_PAGES
5831         if (x == _SC_PHYS_PAGES)
5832                 {*r = Mono_Posix_SysconfName__SC_PHYS_PAGES; return 0;}
5833 #endif /* ndef _SC_PHYS_PAGES */
5834 #ifdef _SC_PII
5835         if (x == _SC_PII)
5836                 {*r = Mono_Posix_SysconfName__SC_PII; return 0;}
5837 #endif /* ndef _SC_PII */
5838 #ifdef _SC_PII_INTERNET
5839         if (x == _SC_PII_INTERNET)
5840                 {*r = Mono_Posix_SysconfName__SC_PII_INTERNET; return 0;}
5841 #endif /* ndef _SC_PII_INTERNET */
5842 #ifdef _SC_PII_INTERNET_DGRAM
5843         if (x == _SC_PII_INTERNET_DGRAM)
5844                 {*r = Mono_Posix_SysconfName__SC_PII_INTERNET_DGRAM; return 0;}
5845 #endif /* ndef _SC_PII_INTERNET_DGRAM */
5846 #ifdef _SC_PII_INTERNET_STREAM
5847         if (x == _SC_PII_INTERNET_STREAM)
5848                 {*r = Mono_Posix_SysconfName__SC_PII_INTERNET_STREAM; return 0;}
5849 #endif /* ndef _SC_PII_INTERNET_STREAM */
5850 #ifdef _SC_PII_OSI
5851         if (x == _SC_PII_OSI)
5852                 {*r = Mono_Posix_SysconfName__SC_PII_OSI; return 0;}
5853 #endif /* ndef _SC_PII_OSI */
5854 #ifdef _SC_PII_OSI_CLTS
5855         if (x == _SC_PII_OSI_CLTS)
5856                 {*r = Mono_Posix_SysconfName__SC_PII_OSI_CLTS; return 0;}
5857 #endif /* ndef _SC_PII_OSI_CLTS */
5858 #ifdef _SC_PII_OSI_COTS
5859         if (x == _SC_PII_OSI_COTS)
5860                 {*r = Mono_Posix_SysconfName__SC_PII_OSI_COTS; return 0;}
5861 #endif /* ndef _SC_PII_OSI_COTS */
5862 #ifdef _SC_PII_OSI_M
5863         if (x == _SC_PII_OSI_M)
5864                 {*r = Mono_Posix_SysconfName__SC_PII_OSI_M; return 0;}
5865 #endif /* ndef _SC_PII_OSI_M */
5866 #ifdef _SC_PII_SOCKET
5867         if (x == _SC_PII_SOCKET)
5868                 {*r = Mono_Posix_SysconfName__SC_PII_SOCKET; return 0;}
5869 #endif /* ndef _SC_PII_SOCKET */
5870 #ifdef _SC_PII_XTI
5871         if (x == _SC_PII_XTI)
5872                 {*r = Mono_Posix_SysconfName__SC_PII_XTI; return 0;}
5873 #endif /* ndef _SC_PII_XTI */
5874 #ifdef _SC_PIPE
5875         if (x == _SC_PIPE)
5876                 {*r = Mono_Posix_SysconfName__SC_PIPE; return 0;}
5877 #endif /* ndef _SC_PIPE */
5878 #ifdef _SC_POLL
5879         if (x == _SC_POLL)
5880                 {*r = Mono_Posix_SysconfName__SC_POLL; return 0;}
5881 #endif /* ndef _SC_POLL */
5882 #ifdef _SC_PRIORITIZED_IO
5883         if (x == _SC_PRIORITIZED_IO)
5884                 {*r = Mono_Posix_SysconfName__SC_PRIORITIZED_IO; return 0;}
5885 #endif /* ndef _SC_PRIORITIZED_IO */
5886 #ifdef _SC_PRIORITY_SCHEDULING
5887         if (x == _SC_PRIORITY_SCHEDULING)
5888                 {*r = Mono_Posix_SysconfName__SC_PRIORITY_SCHEDULING; return 0;}
5889 #endif /* ndef _SC_PRIORITY_SCHEDULING */
5890 #ifdef _SC_READER_WRITER_LOCKS
5891         if (x == _SC_READER_WRITER_LOCKS)
5892                 {*r = Mono_Posix_SysconfName__SC_READER_WRITER_LOCKS; return 0;}
5893 #endif /* ndef _SC_READER_WRITER_LOCKS */
5894 #ifdef _SC_REALTIME_SIGNALS
5895         if (x == _SC_REALTIME_SIGNALS)
5896                 {*r = Mono_Posix_SysconfName__SC_REALTIME_SIGNALS; return 0;}
5897 #endif /* ndef _SC_REALTIME_SIGNALS */
5898 #ifdef _SC_REGEXP
5899         if (x == _SC_REGEXP)
5900                 {*r = Mono_Posix_SysconfName__SC_REGEXP; return 0;}
5901 #endif /* ndef _SC_REGEXP */
5902 #ifdef _SC_REGEX_VERSION
5903         if (x == _SC_REGEX_VERSION)
5904                 {*r = Mono_Posix_SysconfName__SC_REGEX_VERSION; return 0;}
5905 #endif /* ndef _SC_REGEX_VERSION */
5906 #ifdef _SC_RE_DUP_MAX
5907         if (x == _SC_RE_DUP_MAX)
5908                 {*r = Mono_Posix_SysconfName__SC_RE_DUP_MAX; return 0;}
5909 #endif /* ndef _SC_RE_DUP_MAX */
5910 #ifdef _SC_RTSIG_MAX
5911         if (x == _SC_RTSIG_MAX)
5912                 {*r = Mono_Posix_SysconfName__SC_RTSIG_MAX; return 0;}
5913 #endif /* ndef _SC_RTSIG_MAX */
5914 #ifdef _SC_SAVED_IDS
5915         if (x == _SC_SAVED_IDS)
5916                 {*r = Mono_Posix_SysconfName__SC_SAVED_IDS; return 0;}
5917 #endif /* ndef _SC_SAVED_IDS */
5918 #ifdef _SC_SCHAR_MAX
5919         if (x == _SC_SCHAR_MAX)
5920                 {*r = Mono_Posix_SysconfName__SC_SCHAR_MAX; return 0;}
5921 #endif /* ndef _SC_SCHAR_MAX */
5922 #ifdef _SC_SCHAR_MIN
5923         if (x == _SC_SCHAR_MIN)
5924                 {*r = Mono_Posix_SysconfName__SC_SCHAR_MIN; return 0;}
5925 #endif /* ndef _SC_SCHAR_MIN */
5926 #ifdef _SC_SELECT
5927         if (x == _SC_SELECT)
5928                 {*r = Mono_Posix_SysconfName__SC_SELECT; return 0;}
5929 #endif /* ndef _SC_SELECT */
5930 #ifdef _SC_SEMAPHORES
5931         if (x == _SC_SEMAPHORES)
5932                 {*r = Mono_Posix_SysconfName__SC_SEMAPHORES; return 0;}
5933 #endif /* ndef _SC_SEMAPHORES */
5934 #ifdef _SC_SEM_NSEMS_MAX
5935         if (x == _SC_SEM_NSEMS_MAX)
5936                 {*r = Mono_Posix_SysconfName__SC_SEM_NSEMS_MAX; return 0;}
5937 #endif /* ndef _SC_SEM_NSEMS_MAX */
5938 #ifdef _SC_SEM_VALUE_MAX
5939         if (x == _SC_SEM_VALUE_MAX)
5940                 {*r = Mono_Posix_SysconfName__SC_SEM_VALUE_MAX; return 0;}
5941 #endif /* ndef _SC_SEM_VALUE_MAX */
5942 #ifdef _SC_SHARED_MEMORY_OBJECTS
5943         if (x == _SC_SHARED_MEMORY_OBJECTS)
5944                 {*r = Mono_Posix_SysconfName__SC_SHARED_MEMORY_OBJECTS; return 0;}
5945 #endif /* ndef _SC_SHARED_MEMORY_OBJECTS */
5946 #ifdef _SC_SHELL
5947         if (x == _SC_SHELL)
5948                 {*r = Mono_Posix_SysconfName__SC_SHELL; return 0;}
5949 #endif /* ndef _SC_SHELL */
5950 #ifdef _SC_SHRT_MAX
5951         if (x == _SC_SHRT_MAX)
5952                 {*r = Mono_Posix_SysconfName__SC_SHRT_MAX; return 0;}
5953 #endif /* ndef _SC_SHRT_MAX */
5954 #ifdef _SC_SHRT_MIN
5955         if (x == _SC_SHRT_MIN)
5956                 {*r = Mono_Posix_SysconfName__SC_SHRT_MIN; return 0;}
5957 #endif /* ndef _SC_SHRT_MIN */
5958 #ifdef _SC_SIGNALS
5959         if (x == _SC_SIGNALS)
5960                 {*r = Mono_Posix_SysconfName__SC_SIGNALS; return 0;}
5961 #endif /* ndef _SC_SIGNALS */
5962 #ifdef _SC_SIGQUEUE_MAX
5963         if (x == _SC_SIGQUEUE_MAX)
5964                 {*r = Mono_Posix_SysconfName__SC_SIGQUEUE_MAX; return 0;}
5965 #endif /* ndef _SC_SIGQUEUE_MAX */
5966 #ifdef _SC_SINGLE_PROCESS
5967         if (x == _SC_SINGLE_PROCESS)
5968                 {*r = Mono_Posix_SysconfName__SC_SINGLE_PROCESS; return 0;}
5969 #endif /* ndef _SC_SINGLE_PROCESS */
5970 #ifdef _SC_SPAWN
5971         if (x == _SC_SPAWN)
5972                 {*r = Mono_Posix_SysconfName__SC_SPAWN; return 0;}
5973 #endif /* ndef _SC_SPAWN */
5974 #ifdef _SC_SPIN_LOCKS
5975         if (x == _SC_SPIN_LOCKS)
5976                 {*r = Mono_Posix_SysconfName__SC_SPIN_LOCKS; return 0;}
5977 #endif /* ndef _SC_SPIN_LOCKS */
5978 #ifdef _SC_SPORADIC_SERVER
5979         if (x == _SC_SPORADIC_SERVER)
5980                 {*r = Mono_Posix_SysconfName__SC_SPORADIC_SERVER; return 0;}
5981 #endif /* ndef _SC_SPORADIC_SERVER */
5982 #ifdef _SC_SSIZE_MAX
5983         if (x == _SC_SSIZE_MAX)
5984                 {*r = Mono_Posix_SysconfName__SC_SSIZE_MAX; return 0;}
5985 #endif /* ndef _SC_SSIZE_MAX */
5986 #ifdef _SC_STREAMS
5987         if (x == _SC_STREAMS)
5988                 {*r = Mono_Posix_SysconfName__SC_STREAMS; return 0;}
5989 #endif /* ndef _SC_STREAMS */
5990 #ifdef _SC_STREAM_MAX
5991         if (x == _SC_STREAM_MAX)
5992                 {*r = Mono_Posix_SysconfName__SC_STREAM_MAX; return 0;}
5993 #endif /* ndef _SC_STREAM_MAX */
5994 #ifdef _SC_SYMLOOP_MAX
5995         if (x == _SC_SYMLOOP_MAX)
5996                 {*r = Mono_Posix_SysconfName__SC_SYMLOOP_MAX; return 0;}
5997 #endif /* ndef _SC_SYMLOOP_MAX */
5998 #ifdef _SC_SYNCHRONIZED_IO
5999         if (x == _SC_SYNCHRONIZED_IO)
6000                 {*r = Mono_Posix_SysconfName__SC_SYNCHRONIZED_IO; return 0;}
6001 #endif /* ndef _SC_SYNCHRONIZED_IO */
6002 #ifdef _SC_SYSTEM_DATABASE
6003         if (x == _SC_SYSTEM_DATABASE)
6004                 {*r = Mono_Posix_SysconfName__SC_SYSTEM_DATABASE; return 0;}
6005 #endif /* ndef _SC_SYSTEM_DATABASE */
6006 #ifdef _SC_SYSTEM_DATABASE_R
6007         if (x == _SC_SYSTEM_DATABASE_R)
6008                 {*r = Mono_Posix_SysconfName__SC_SYSTEM_DATABASE_R; return 0;}
6009 #endif /* ndef _SC_SYSTEM_DATABASE_R */
6010 #ifdef _SC_THREADS
6011         if (x == _SC_THREADS)
6012                 {*r = Mono_Posix_SysconfName__SC_THREADS; return 0;}
6013 #endif /* ndef _SC_THREADS */
6014 #ifdef _SC_THREAD_ATTR_STACKADDR
6015         if (x == _SC_THREAD_ATTR_STACKADDR)
6016                 {*r = Mono_Posix_SysconfName__SC_THREAD_ATTR_STACKADDR; return 0;}
6017 #endif /* ndef _SC_THREAD_ATTR_STACKADDR */
6018 #ifdef _SC_THREAD_ATTR_STACKSIZE
6019         if (x == _SC_THREAD_ATTR_STACKSIZE)
6020                 {*r = Mono_Posix_SysconfName__SC_THREAD_ATTR_STACKSIZE; return 0;}
6021 #endif /* ndef _SC_THREAD_ATTR_STACKSIZE */
6022 #ifdef _SC_THREAD_CPUTIME
6023         if (x == _SC_THREAD_CPUTIME)
6024                 {*r = Mono_Posix_SysconfName__SC_THREAD_CPUTIME; return 0;}
6025 #endif /* ndef _SC_THREAD_CPUTIME */
6026 #ifdef _SC_THREAD_DESTRUCTOR_ITERATIONS
6027         if (x == _SC_THREAD_DESTRUCTOR_ITERATIONS)
6028                 {*r = Mono_Posix_SysconfName__SC_THREAD_DESTRUCTOR_ITERATIONS; return 0;}
6029 #endif /* ndef _SC_THREAD_DESTRUCTOR_ITERATIONS */
6030 #ifdef _SC_THREAD_KEYS_MAX
6031         if (x == _SC_THREAD_KEYS_MAX)
6032                 {*r = Mono_Posix_SysconfName__SC_THREAD_KEYS_MAX; return 0;}
6033 #endif /* ndef _SC_THREAD_KEYS_MAX */
6034 #ifdef _SC_THREAD_PRIORITY_SCHEDULING
6035         if (x == _SC_THREAD_PRIORITY_SCHEDULING)
6036                 {*r = Mono_Posix_SysconfName__SC_THREAD_PRIORITY_SCHEDULING; return 0;}
6037 #endif /* ndef _SC_THREAD_PRIORITY_SCHEDULING */
6038 #ifdef _SC_THREAD_PRIO_INHERIT
6039         if (x == _SC_THREAD_PRIO_INHERIT)
6040                 {*r = Mono_Posix_SysconfName__SC_THREAD_PRIO_INHERIT; return 0;}
6041 #endif /* ndef _SC_THREAD_PRIO_INHERIT */
6042 #ifdef _SC_THREAD_PRIO_PROTECT
6043         if (x == _SC_THREAD_PRIO_PROTECT)
6044                 {*r = Mono_Posix_SysconfName__SC_THREAD_PRIO_PROTECT; return 0;}
6045 #endif /* ndef _SC_THREAD_PRIO_PROTECT */
6046 #ifdef _SC_THREAD_PROCESS_SHARED
6047         if (x == _SC_THREAD_PROCESS_SHARED)
6048                 {*r = Mono_Posix_SysconfName__SC_THREAD_PROCESS_SHARED; return 0;}
6049 #endif /* ndef _SC_THREAD_PROCESS_SHARED */
6050 #ifdef _SC_THREAD_SAFE_FUNCTIONS
6051         if (x == _SC_THREAD_SAFE_FUNCTIONS)
6052                 {*r = Mono_Posix_SysconfName__SC_THREAD_SAFE_FUNCTIONS; return 0;}
6053 #endif /* ndef _SC_THREAD_SAFE_FUNCTIONS */
6054 #ifdef _SC_THREAD_SPORADIC_SERVER
6055         if (x == _SC_THREAD_SPORADIC_SERVER)
6056                 {*r = Mono_Posix_SysconfName__SC_THREAD_SPORADIC_SERVER; return 0;}
6057 #endif /* ndef _SC_THREAD_SPORADIC_SERVER */
6058 #ifdef _SC_THREAD_STACK_MIN
6059         if (x == _SC_THREAD_STACK_MIN)
6060                 {*r = Mono_Posix_SysconfName__SC_THREAD_STACK_MIN; return 0;}
6061 #endif /* ndef _SC_THREAD_STACK_MIN */
6062 #ifdef _SC_THREAD_THREADS_MAX
6063         if (x == _SC_THREAD_THREADS_MAX)
6064                 {*r = Mono_Posix_SysconfName__SC_THREAD_THREADS_MAX; return 0;}
6065 #endif /* ndef _SC_THREAD_THREADS_MAX */
6066 #ifdef _SC_TIMEOUTS
6067         if (x == _SC_TIMEOUTS)
6068                 {*r = Mono_Posix_SysconfName__SC_TIMEOUTS; return 0;}
6069 #endif /* ndef _SC_TIMEOUTS */
6070 #ifdef _SC_TIMERS
6071         if (x == _SC_TIMERS)
6072                 {*r = Mono_Posix_SysconfName__SC_TIMERS; return 0;}
6073 #endif /* ndef _SC_TIMERS */
6074 #ifdef _SC_TIMER_MAX
6075         if (x == _SC_TIMER_MAX)
6076                 {*r = Mono_Posix_SysconfName__SC_TIMER_MAX; return 0;}
6077 #endif /* ndef _SC_TIMER_MAX */
6078 #ifdef _SC_TRACE
6079         if (x == _SC_TRACE)
6080                 {*r = Mono_Posix_SysconfName__SC_TRACE; return 0;}
6081 #endif /* ndef _SC_TRACE */
6082 #ifdef _SC_TRACE_EVENT_FILTER
6083         if (x == _SC_TRACE_EVENT_FILTER)
6084                 {*r = Mono_Posix_SysconfName__SC_TRACE_EVENT_FILTER; return 0;}
6085 #endif /* ndef _SC_TRACE_EVENT_FILTER */
6086 #ifdef _SC_TRACE_INHERIT
6087         if (x == _SC_TRACE_INHERIT)
6088                 {*r = Mono_Posix_SysconfName__SC_TRACE_INHERIT; return 0;}
6089 #endif /* ndef _SC_TRACE_INHERIT */
6090 #ifdef _SC_TRACE_LOG
6091         if (x == _SC_TRACE_LOG)
6092                 {*r = Mono_Posix_SysconfName__SC_TRACE_LOG; return 0;}
6093 #endif /* ndef _SC_TRACE_LOG */
6094 #ifdef _SC_TTY_NAME_MAX
6095         if (x == _SC_TTY_NAME_MAX)
6096                 {*r = Mono_Posix_SysconfName__SC_TTY_NAME_MAX; return 0;}
6097 #endif /* ndef _SC_TTY_NAME_MAX */
6098 #ifdef _SC_TYPED_MEMORY_OBJECTS
6099         if (x == _SC_TYPED_MEMORY_OBJECTS)
6100                 {*r = Mono_Posix_SysconfName__SC_TYPED_MEMORY_OBJECTS; return 0;}
6101 #endif /* ndef _SC_TYPED_MEMORY_OBJECTS */
6102 #ifdef _SC_TZNAME_MAX
6103         if (x == _SC_TZNAME_MAX)
6104                 {*r = Mono_Posix_SysconfName__SC_TZNAME_MAX; return 0;}
6105 #endif /* ndef _SC_TZNAME_MAX */
6106 #ifdef _SC_T_IOV_MAX
6107         if (x == _SC_T_IOV_MAX)
6108                 {*r = Mono_Posix_SysconfName__SC_T_IOV_MAX; return 0;}
6109 #endif /* ndef _SC_T_IOV_MAX */
6110 #ifdef _SC_UCHAR_MAX
6111         if (x == _SC_UCHAR_MAX)
6112                 {*r = Mono_Posix_SysconfName__SC_UCHAR_MAX; return 0;}
6113 #endif /* ndef _SC_UCHAR_MAX */
6114 #ifdef _SC_UINT_MAX
6115         if (x == _SC_UINT_MAX)
6116                 {*r = Mono_Posix_SysconfName__SC_UINT_MAX; return 0;}
6117 #endif /* ndef _SC_UINT_MAX */
6118 #ifdef _SC_UIO_MAXIOV
6119         if (x == _SC_UIO_MAXIOV)
6120                 {*r = Mono_Posix_SysconfName__SC_UIO_MAXIOV; return 0;}
6121 #endif /* ndef _SC_UIO_MAXIOV */
6122 #ifdef _SC_ULONG_MAX
6123         if (x == _SC_ULONG_MAX)
6124                 {*r = Mono_Posix_SysconfName__SC_ULONG_MAX; return 0;}
6125 #endif /* ndef _SC_ULONG_MAX */
6126 #ifdef _SC_USER_GROUPS
6127         if (x == _SC_USER_GROUPS)
6128                 {*r = Mono_Posix_SysconfName__SC_USER_GROUPS; return 0;}
6129 #endif /* ndef _SC_USER_GROUPS */
6130 #ifdef _SC_USER_GROUPS_R
6131         if (x == _SC_USER_GROUPS_R)
6132                 {*r = Mono_Posix_SysconfName__SC_USER_GROUPS_R; return 0;}
6133 #endif /* ndef _SC_USER_GROUPS_R */
6134 #ifdef _SC_USHRT_MAX
6135         if (x == _SC_USHRT_MAX)
6136                 {*r = Mono_Posix_SysconfName__SC_USHRT_MAX; return 0;}
6137 #endif /* ndef _SC_USHRT_MAX */
6138 #ifdef _SC_V6_ILP32_OFF32
6139         if (x == _SC_V6_ILP32_OFF32)
6140                 {*r = Mono_Posix_SysconfName__SC_V6_ILP32_OFF32; return 0;}
6141 #endif /* ndef _SC_V6_ILP32_OFF32 */
6142 #ifdef _SC_V6_ILP32_OFFBIG
6143         if (x == _SC_V6_ILP32_OFFBIG)
6144                 {*r = Mono_Posix_SysconfName__SC_V6_ILP32_OFFBIG; return 0;}
6145 #endif /* ndef _SC_V6_ILP32_OFFBIG */
6146 #ifdef _SC_V6_LP64_OFF64
6147         if (x == _SC_V6_LP64_OFF64)
6148                 {*r = Mono_Posix_SysconfName__SC_V6_LP64_OFF64; return 0;}
6149 #endif /* ndef _SC_V6_LP64_OFF64 */
6150 #ifdef _SC_V6_LPBIG_OFFBIG
6151         if (x == _SC_V6_LPBIG_OFFBIG)
6152                 {*r = Mono_Posix_SysconfName__SC_V6_LPBIG_OFFBIG; return 0;}
6153 #endif /* ndef _SC_V6_LPBIG_OFFBIG */
6154 #ifdef _SC_VERSION
6155         if (x == _SC_VERSION)
6156                 {*r = Mono_Posix_SysconfName__SC_VERSION; return 0;}
6157 #endif /* ndef _SC_VERSION */
6158 #ifdef _SC_WORD_BIT
6159         if (x == _SC_WORD_BIT)
6160                 {*r = Mono_Posix_SysconfName__SC_WORD_BIT; return 0;}
6161 #endif /* ndef _SC_WORD_BIT */
6162 #ifdef _SC_XBS5_ILP32_OFF32
6163         if (x == _SC_XBS5_ILP32_OFF32)
6164                 {*r = Mono_Posix_SysconfName__SC_XBS5_ILP32_OFF32; return 0;}
6165 #endif /* ndef _SC_XBS5_ILP32_OFF32 */
6166 #ifdef _SC_XBS5_ILP32_OFFBIG
6167         if (x == _SC_XBS5_ILP32_OFFBIG)
6168                 {*r = Mono_Posix_SysconfName__SC_XBS5_ILP32_OFFBIG; return 0;}
6169 #endif /* ndef _SC_XBS5_ILP32_OFFBIG */
6170 #ifdef _SC_XBS5_LP64_OFF64
6171         if (x == _SC_XBS5_LP64_OFF64)
6172                 {*r = Mono_Posix_SysconfName__SC_XBS5_LP64_OFF64; return 0;}
6173 #endif /* ndef _SC_XBS5_LP64_OFF64 */
6174 #ifdef _SC_XBS5_LPBIG_OFFBIG
6175         if (x == _SC_XBS5_LPBIG_OFFBIG)
6176                 {*r = Mono_Posix_SysconfName__SC_XBS5_LPBIG_OFFBIG; return 0;}
6177 #endif /* ndef _SC_XBS5_LPBIG_OFFBIG */
6178 #ifdef _SC_XOPEN_CRYPT
6179         if (x == _SC_XOPEN_CRYPT)
6180                 {*r = Mono_Posix_SysconfName__SC_XOPEN_CRYPT; return 0;}
6181 #endif /* ndef _SC_XOPEN_CRYPT */
6182 #ifdef _SC_XOPEN_ENH_I18N
6183         if (x == _SC_XOPEN_ENH_I18N)
6184                 {*r = Mono_Posix_SysconfName__SC_XOPEN_ENH_I18N; return 0;}
6185 #endif /* ndef _SC_XOPEN_ENH_I18N */
6186 #ifdef _SC_XOPEN_LEGACY
6187         if (x == _SC_XOPEN_LEGACY)
6188                 {*r = Mono_Posix_SysconfName__SC_XOPEN_LEGACY; return 0;}
6189 #endif /* ndef _SC_XOPEN_LEGACY */
6190 #ifdef _SC_XOPEN_REALTIME
6191         if (x == _SC_XOPEN_REALTIME)
6192                 {*r = Mono_Posix_SysconfName__SC_XOPEN_REALTIME; return 0;}
6193 #endif /* ndef _SC_XOPEN_REALTIME */
6194 #ifdef _SC_XOPEN_REALTIME_THREADS
6195         if (x == _SC_XOPEN_REALTIME_THREADS)
6196                 {*r = Mono_Posix_SysconfName__SC_XOPEN_REALTIME_THREADS; return 0;}
6197 #endif /* ndef _SC_XOPEN_REALTIME_THREADS */
6198 #ifdef _SC_XOPEN_SHM
6199         if (x == _SC_XOPEN_SHM)
6200                 {*r = Mono_Posix_SysconfName__SC_XOPEN_SHM; return 0;}
6201 #endif /* ndef _SC_XOPEN_SHM */
6202 #ifdef _SC_XOPEN_UNIX
6203         if (x == _SC_XOPEN_UNIX)
6204                 {*r = Mono_Posix_SysconfName__SC_XOPEN_UNIX; return 0;}
6205 #endif /* ndef _SC_XOPEN_UNIX */
6206 #ifdef _SC_XOPEN_VERSION
6207         if (x == _SC_XOPEN_VERSION)
6208                 {*r = Mono_Posix_SysconfName__SC_XOPEN_VERSION; return 0;}
6209 #endif /* ndef _SC_XOPEN_VERSION */
6210 #ifdef _SC_XOPEN_XCU_VERSION
6211         if (x == _SC_XOPEN_XCU_VERSION)
6212                 {*r = Mono_Posix_SysconfName__SC_XOPEN_XCU_VERSION; return 0;}
6213 #endif /* ndef _SC_XOPEN_XCU_VERSION */
6214 #ifdef _SC_XOPEN_XPG2
6215         if (x == _SC_XOPEN_XPG2)
6216                 {*r = Mono_Posix_SysconfName__SC_XOPEN_XPG2; return 0;}
6217 #endif /* ndef _SC_XOPEN_XPG2 */
6218 #ifdef _SC_XOPEN_XPG3
6219         if (x == _SC_XOPEN_XPG3)
6220                 {*r = Mono_Posix_SysconfName__SC_XOPEN_XPG3; return 0;}
6221 #endif /* ndef _SC_XOPEN_XPG3 */
6222 #ifdef _SC_XOPEN_XPG4
6223         if (x == _SC_XOPEN_XPG4)
6224                 {*r = Mono_Posix_SysconfName__SC_XOPEN_XPG4; return 0;}
6225 #endif /* ndef _SC_XOPEN_XPG4 */
6226         errno = EINVAL; return -1;
6227 }
6228
6229 int Mono_Posix_FromSyslogFacility (int x, int *r)
6230 {
6231         *r = 0;
6232         if (x == Mono_Posix_SyslogFacility_LOG_AUTH)
6233 #ifdef LOG_AUTH
6234                 {*r = LOG_AUTH; return 0;}
6235 #else /* def LOG_AUTH */
6236                 {errno = EINVAL; return -1;}
6237 #endif /* ndef LOG_AUTH */
6238         if (x == Mono_Posix_SyslogFacility_LOG_AUTHPRIV)
6239 #ifdef LOG_AUTHPRIV
6240                 {*r = LOG_AUTHPRIV; return 0;}
6241 #else /* def LOG_AUTHPRIV */
6242                 {errno = EINVAL; return -1;}
6243 #endif /* ndef LOG_AUTHPRIV */
6244         if (x == Mono_Posix_SyslogFacility_LOG_CRON)
6245 #ifdef LOG_CRON
6246                 {*r = LOG_CRON; return 0;}
6247 #else /* def LOG_CRON */
6248                 {errno = EINVAL; return -1;}
6249 #endif /* ndef LOG_CRON */
6250         if (x == Mono_Posix_SyslogFacility_LOG_DAEMON)
6251 #ifdef LOG_DAEMON
6252                 {*r = LOG_DAEMON; return 0;}
6253 #else /* def LOG_DAEMON */
6254                 {errno = EINVAL; return -1;}
6255 #endif /* ndef LOG_DAEMON */
6256         if (x == Mono_Posix_SyslogFacility_LOG_FTP)
6257 #ifdef LOG_FTP
6258                 {*r = LOG_FTP; return 0;}
6259 #else /* def LOG_FTP */
6260                 {errno = EINVAL; return -1;}
6261 #endif /* ndef LOG_FTP */
6262         if (x == Mono_Posix_SyslogFacility_LOG_KERN)
6263 #ifdef LOG_KERN
6264                 {*r = LOG_KERN; return 0;}
6265 #else /* def LOG_KERN */
6266                 {errno = EINVAL; return -1;}
6267 #endif /* ndef LOG_KERN */
6268         if (x == Mono_Posix_SyslogFacility_LOG_LOCAL0)
6269 #ifdef LOG_LOCAL0
6270                 {*r = LOG_LOCAL0; return 0;}
6271 #else /* def LOG_LOCAL0 */
6272                 {errno = EINVAL; return -1;}
6273 #endif /* ndef LOG_LOCAL0 */
6274         if (x == Mono_Posix_SyslogFacility_LOG_LOCAL1)
6275 #ifdef LOG_LOCAL1
6276                 {*r = LOG_LOCAL1; return 0;}
6277 #else /* def LOG_LOCAL1 */
6278                 {errno = EINVAL; return -1;}
6279 #endif /* ndef LOG_LOCAL1 */
6280         if (x == Mono_Posix_SyslogFacility_LOG_LOCAL2)
6281 #ifdef LOG_LOCAL2
6282                 {*r = LOG_LOCAL2; return 0;}
6283 #else /* def LOG_LOCAL2 */
6284                 {errno = EINVAL; return -1;}
6285 #endif /* ndef LOG_LOCAL2 */
6286         if (x == Mono_Posix_SyslogFacility_LOG_LOCAL3)
6287 #ifdef LOG_LOCAL3
6288                 {*r = LOG_LOCAL3; return 0;}
6289 #else /* def LOG_LOCAL3 */
6290                 {errno = EINVAL; return -1;}
6291 #endif /* ndef LOG_LOCAL3 */
6292         if (x == Mono_Posix_SyslogFacility_LOG_LOCAL4)
6293 #ifdef LOG_LOCAL4
6294                 {*r = LOG_LOCAL4; return 0;}
6295 #else /* def LOG_LOCAL4 */
6296                 {errno = EINVAL; return -1;}
6297 #endif /* ndef LOG_LOCAL4 */
6298         if (x == Mono_Posix_SyslogFacility_LOG_LOCAL5)
6299 #ifdef LOG_LOCAL5
6300                 {*r = LOG_LOCAL5; return 0;}
6301 #else /* def LOG_LOCAL5 */
6302                 {errno = EINVAL; return -1;}
6303 #endif /* ndef LOG_LOCAL5 */
6304         if (x == Mono_Posix_SyslogFacility_LOG_LOCAL6)
6305 #ifdef LOG_LOCAL6
6306                 {*r = LOG_LOCAL6; return 0;}
6307 #else /* def LOG_LOCAL6 */
6308                 {errno = EINVAL; return -1;}
6309 #endif /* ndef LOG_LOCAL6 */
6310         if (x == Mono_Posix_SyslogFacility_LOG_LOCAL7)
6311 #ifdef LOG_LOCAL7
6312                 {*r = LOG_LOCAL7; return 0;}
6313 #else /* def LOG_LOCAL7 */
6314                 {errno = EINVAL; return -1;}
6315 #endif /* ndef LOG_LOCAL7 */
6316         if (x == Mono_Posix_SyslogFacility_LOG_LPR)
6317 #ifdef LOG_LPR
6318                 {*r = LOG_LPR; return 0;}
6319 #else /* def LOG_LPR */
6320                 {errno = EINVAL; return -1;}
6321 #endif /* ndef LOG_LPR */
6322         if (x == Mono_Posix_SyslogFacility_LOG_MAIL)
6323 #ifdef LOG_MAIL
6324                 {*r = LOG_MAIL; return 0;}
6325 #else /* def LOG_MAIL */
6326                 {errno = EINVAL; return -1;}
6327 #endif /* ndef LOG_MAIL */
6328         if (x == Mono_Posix_SyslogFacility_LOG_NEWS)
6329 #ifdef LOG_NEWS
6330                 {*r = LOG_NEWS; return 0;}
6331 #else /* def LOG_NEWS */
6332                 {errno = EINVAL; return -1;}
6333 #endif /* ndef LOG_NEWS */
6334         if (x == Mono_Posix_SyslogFacility_LOG_SYSLOG)
6335 #ifdef LOG_SYSLOG
6336                 {*r = LOG_SYSLOG; return 0;}
6337 #else /* def LOG_SYSLOG */
6338                 {errno = EINVAL; return -1;}
6339 #endif /* ndef LOG_SYSLOG */
6340         if (x == Mono_Posix_SyslogFacility_LOG_USER)
6341 #ifdef LOG_USER
6342                 {*r = LOG_USER; return 0;}
6343 #else /* def LOG_USER */
6344                 {errno = EINVAL; return -1;}
6345 #endif /* ndef LOG_USER */
6346         if (x == Mono_Posix_SyslogFacility_LOG_UUCP)
6347 #ifdef LOG_UUCP
6348                 {*r = LOG_UUCP; return 0;}
6349 #else /* def LOG_UUCP */
6350                 {errno = EINVAL; return -1;}
6351 #endif /* ndef LOG_UUCP */
6352         if (x == 0)
6353                 return 0;
6354         errno = EINVAL; return -1;
6355 }
6356
6357 int Mono_Posix_ToSyslogFacility (int x, int *r)
6358 {
6359         *r = 0;
6360         if (x == 0)
6361                 return 0;
6362 #ifdef LOG_AUTH
6363         if (x == LOG_AUTH)
6364                 {*r = Mono_Posix_SyslogFacility_LOG_AUTH; return 0;}
6365 #endif /* ndef LOG_AUTH */
6366 #ifdef LOG_AUTHPRIV
6367         if (x == LOG_AUTHPRIV)
6368                 {*r = Mono_Posix_SyslogFacility_LOG_AUTHPRIV; return 0;}
6369 #endif /* ndef LOG_AUTHPRIV */
6370 #ifdef LOG_CRON
6371         if (x == LOG_CRON)
6372                 {*r = Mono_Posix_SyslogFacility_LOG_CRON; return 0;}
6373 #endif /* ndef LOG_CRON */
6374 #ifdef LOG_DAEMON
6375         if (x == LOG_DAEMON)
6376                 {*r = Mono_Posix_SyslogFacility_LOG_DAEMON; return 0;}
6377 #endif /* ndef LOG_DAEMON */
6378 #ifdef LOG_FTP
6379         if (x == LOG_FTP)
6380                 {*r = Mono_Posix_SyslogFacility_LOG_FTP; return 0;}
6381 #endif /* ndef LOG_FTP */
6382 #ifdef LOG_KERN
6383         if (x == LOG_KERN)
6384                 {*r = Mono_Posix_SyslogFacility_LOG_KERN; return 0;}
6385 #endif /* ndef LOG_KERN */
6386 #ifdef LOG_LOCAL0
6387         if (x == LOG_LOCAL0)
6388                 {*r = Mono_Posix_SyslogFacility_LOG_LOCAL0; return 0;}
6389 #endif /* ndef LOG_LOCAL0 */
6390 #ifdef LOG_LOCAL1
6391         if (x == LOG_LOCAL1)
6392                 {*r = Mono_Posix_SyslogFacility_LOG_LOCAL1; return 0;}
6393 #endif /* ndef LOG_LOCAL1 */
6394 #ifdef LOG_LOCAL2
6395         if (x == LOG_LOCAL2)
6396                 {*r = Mono_Posix_SyslogFacility_LOG_LOCAL2; return 0;}
6397 #endif /* ndef LOG_LOCAL2 */
6398 #ifdef LOG_LOCAL3
6399         if (x == LOG_LOCAL3)
6400                 {*r = Mono_Posix_SyslogFacility_LOG_LOCAL3; return 0;}
6401 #endif /* ndef LOG_LOCAL3 */
6402 #ifdef LOG_LOCAL4
6403         if (x == LOG_LOCAL4)
6404                 {*r = Mono_Posix_SyslogFacility_LOG_LOCAL4; return 0;}
6405 #endif /* ndef LOG_LOCAL4 */
6406 #ifdef LOG_LOCAL5
6407         if (x == LOG_LOCAL5)
6408                 {*r = Mono_Posix_SyslogFacility_LOG_LOCAL5; return 0;}
6409 #endif /* ndef LOG_LOCAL5 */
6410 #ifdef LOG_LOCAL6
6411         if (x == LOG_LOCAL6)
6412                 {*r = Mono_Posix_SyslogFacility_LOG_LOCAL6; return 0;}
6413 #endif /* ndef LOG_LOCAL6 */
6414 #ifdef LOG_LOCAL7
6415         if (x == LOG_LOCAL7)
6416                 {*r = Mono_Posix_SyslogFacility_LOG_LOCAL7; return 0;}
6417 #endif /* ndef LOG_LOCAL7 */
6418 #ifdef LOG_LPR
6419         if (x == LOG_LPR)
6420                 {*r = Mono_Posix_SyslogFacility_LOG_LPR; return 0;}
6421 #endif /* ndef LOG_LPR */
6422 #ifdef LOG_MAIL
6423         if (x == LOG_MAIL)
6424                 {*r = Mono_Posix_SyslogFacility_LOG_MAIL; return 0;}
6425 #endif /* ndef LOG_MAIL */
6426 #ifdef LOG_NEWS
6427         if (x == LOG_NEWS)
6428                 {*r = Mono_Posix_SyslogFacility_LOG_NEWS; return 0;}
6429 #endif /* ndef LOG_NEWS */
6430 #ifdef LOG_SYSLOG
6431         if (x == LOG_SYSLOG)
6432                 {*r = Mono_Posix_SyslogFacility_LOG_SYSLOG; return 0;}
6433 #endif /* ndef LOG_SYSLOG */
6434 #ifdef LOG_USER
6435         if (x == LOG_USER)
6436                 {*r = Mono_Posix_SyslogFacility_LOG_USER; return 0;}
6437 #endif /* ndef LOG_USER */
6438 #ifdef LOG_UUCP
6439         if (x == LOG_UUCP)
6440                 {*r = Mono_Posix_SyslogFacility_LOG_UUCP; return 0;}
6441 #endif /* ndef LOG_UUCP */
6442         errno = EINVAL; return -1;
6443 }
6444
6445 int Mono_Posix_FromSyslogLevel (int x, int *r)
6446 {
6447         *r = 0;
6448         if (x == Mono_Posix_SyslogLevel_LOG_ALERT)
6449 #ifdef LOG_ALERT
6450                 {*r = LOG_ALERT; return 0;}
6451 #else /* def LOG_ALERT */
6452                 {errno = EINVAL; return -1;}
6453 #endif /* ndef LOG_ALERT */
6454         if (x == Mono_Posix_SyslogLevel_LOG_CRIT)
6455 #ifdef LOG_CRIT
6456                 {*r = LOG_CRIT; return 0;}
6457 #else /* def LOG_CRIT */
6458                 {errno = EINVAL; return -1;}
6459 #endif /* ndef LOG_CRIT */
6460         if (x == Mono_Posix_SyslogLevel_LOG_DEBUG)
6461 #ifdef LOG_DEBUG
6462                 {*r = LOG_DEBUG; return 0;}
6463 #else /* def LOG_DEBUG */
6464                 {errno = EINVAL; return -1;}
6465 #endif /* ndef LOG_DEBUG */
6466         if (x == Mono_Posix_SyslogLevel_LOG_EMERG)
6467 #ifdef LOG_EMERG
6468                 {*r = LOG_EMERG; return 0;}
6469 #else /* def LOG_EMERG */
6470                 {errno = EINVAL; return -1;}
6471 #endif /* ndef LOG_EMERG */
6472         if (x == Mono_Posix_SyslogLevel_LOG_ERR)
6473 #ifdef LOG_ERR
6474                 {*r = LOG_ERR; return 0;}
6475 #else /* def LOG_ERR */
6476                 {errno = EINVAL; return -1;}
6477 #endif /* ndef LOG_ERR */
6478         if (x == Mono_Posix_SyslogLevel_LOG_INFO)
6479 #ifdef LOG_INFO
6480                 {*r = LOG_INFO; return 0;}
6481 #else /* def LOG_INFO */
6482                 {errno = EINVAL; return -1;}
6483 #endif /* ndef LOG_INFO */
6484         if (x == Mono_Posix_SyslogLevel_LOG_NOTICE)
6485 #ifdef LOG_NOTICE
6486                 {*r = LOG_NOTICE; return 0;}
6487 #else /* def LOG_NOTICE */
6488                 {errno = EINVAL; return -1;}
6489 #endif /* ndef LOG_NOTICE */
6490         if (x == Mono_Posix_SyslogLevel_LOG_WARNING)
6491 #ifdef LOG_WARNING
6492                 {*r = LOG_WARNING; return 0;}
6493 #else /* def LOG_WARNING */
6494                 {errno = EINVAL; return -1;}
6495 #endif /* ndef LOG_WARNING */
6496         if (x == 0)
6497                 return 0;
6498         errno = EINVAL; return -1;
6499 }
6500
6501 int Mono_Posix_ToSyslogLevel (int x, int *r)
6502 {
6503         *r = 0;
6504         if (x == 0)
6505                 return 0;
6506 #ifdef LOG_ALERT
6507         if (x == LOG_ALERT)
6508                 {*r = Mono_Posix_SyslogLevel_LOG_ALERT; return 0;}
6509 #endif /* ndef LOG_ALERT */
6510 #ifdef LOG_CRIT
6511         if (x == LOG_CRIT)
6512                 {*r = Mono_Posix_SyslogLevel_LOG_CRIT; return 0;}
6513 #endif /* ndef LOG_CRIT */
6514 #ifdef LOG_DEBUG
6515         if (x == LOG_DEBUG)
6516                 {*r = Mono_Posix_SyslogLevel_LOG_DEBUG; return 0;}
6517 #endif /* ndef LOG_DEBUG */
6518 #ifdef LOG_EMERG
6519         if (x == LOG_EMERG)
6520                 {*r = Mono_Posix_SyslogLevel_LOG_EMERG; return 0;}
6521 #endif /* ndef LOG_EMERG */
6522 #ifdef LOG_ERR
6523         if (x == LOG_ERR)
6524                 {*r = Mono_Posix_SyslogLevel_LOG_ERR; return 0;}
6525 #endif /* ndef LOG_ERR */
6526 #ifdef LOG_INFO
6527         if (x == LOG_INFO)
6528                 {*r = Mono_Posix_SyslogLevel_LOG_INFO; return 0;}
6529 #endif /* ndef LOG_INFO */
6530 #ifdef LOG_NOTICE
6531         if (x == LOG_NOTICE)
6532                 {*r = Mono_Posix_SyslogLevel_LOG_NOTICE; return 0;}
6533 #endif /* ndef LOG_NOTICE */
6534 #ifdef LOG_WARNING
6535         if (x == LOG_WARNING)
6536                 {*r = Mono_Posix_SyslogLevel_LOG_WARNING; return 0;}
6537 #endif /* ndef LOG_WARNING */
6538         errno = EINVAL; return -1;
6539 }
6540
6541 int Mono_Posix_FromSyslogOptions (int x, int *r)
6542 {
6543         *r = 0;
6544         if ((x & Mono_Posix_SyslogOptions_LOG_CONS) == Mono_Posix_SyslogOptions_LOG_CONS)
6545 #ifdef LOG_CONS
6546                 *r |= LOG_CONS;
6547 #else /* def LOG_CONS */
6548                 {errno = EINVAL; return -1;}
6549 #endif /* ndef LOG_CONS */
6550         if ((x & Mono_Posix_SyslogOptions_LOG_NDELAY) == Mono_Posix_SyslogOptions_LOG_NDELAY)
6551 #ifdef LOG_NDELAY
6552                 *r |= LOG_NDELAY;
6553 #else /* def LOG_NDELAY */
6554                 {errno = EINVAL; return -1;}
6555 #endif /* ndef LOG_NDELAY */
6556         if ((x & Mono_Posix_SyslogOptions_LOG_NOWAIT) == Mono_Posix_SyslogOptions_LOG_NOWAIT)
6557 #ifdef LOG_NOWAIT
6558                 *r |= LOG_NOWAIT;
6559 #else /* def LOG_NOWAIT */
6560                 {errno = EINVAL; return -1;}
6561 #endif /* ndef LOG_NOWAIT */
6562         if ((x & Mono_Posix_SyslogOptions_LOG_ODELAY) == Mono_Posix_SyslogOptions_LOG_ODELAY)
6563 #ifdef LOG_ODELAY
6564                 *r |= LOG_ODELAY;
6565 #else /* def LOG_ODELAY */
6566                 {errno = EINVAL; return -1;}
6567 #endif /* ndef LOG_ODELAY */
6568         if ((x & Mono_Posix_SyslogOptions_LOG_PERROR) == Mono_Posix_SyslogOptions_LOG_PERROR)
6569 #ifdef LOG_PERROR
6570                 *r |= LOG_PERROR;
6571 #else /* def LOG_PERROR */
6572                 {errno = EINVAL; return -1;}
6573 #endif /* ndef LOG_PERROR */
6574         if ((x & Mono_Posix_SyslogOptions_LOG_PID) == Mono_Posix_SyslogOptions_LOG_PID)
6575 #ifdef LOG_PID
6576                 *r |= LOG_PID;
6577 #else /* def LOG_PID */
6578                 {errno = EINVAL; return -1;}
6579 #endif /* ndef LOG_PID */
6580         if (x == 0)
6581                 return 0;
6582         return 0;
6583 }
6584
6585 int Mono_Posix_ToSyslogOptions (int x, int *r)
6586 {
6587         *r = 0;
6588         if (x == 0)
6589                 return 0;
6590 #ifdef LOG_CONS
6591         if ((x & LOG_CONS) == LOG_CONS)
6592                 *r |= Mono_Posix_SyslogOptions_LOG_CONS;
6593 #endif /* ndef LOG_CONS */
6594 #ifdef LOG_NDELAY
6595         if ((x & LOG_NDELAY) == LOG_NDELAY)
6596                 *r |= Mono_Posix_SyslogOptions_LOG_NDELAY;
6597 #endif /* ndef LOG_NDELAY */
6598 #ifdef LOG_NOWAIT
6599         if ((x & LOG_NOWAIT) == LOG_NOWAIT)
6600                 *r |= Mono_Posix_SyslogOptions_LOG_NOWAIT;
6601 #endif /* ndef LOG_NOWAIT */
6602 #ifdef LOG_ODELAY
6603         if ((x & LOG_ODELAY) == LOG_ODELAY)
6604                 *r |= Mono_Posix_SyslogOptions_LOG_ODELAY;
6605 #endif /* ndef LOG_ODELAY */
6606 #ifdef LOG_PERROR
6607         if ((x & LOG_PERROR) == LOG_PERROR)
6608                 *r |= Mono_Posix_SyslogOptions_LOG_PERROR;
6609 #endif /* ndef LOG_PERROR */
6610 #ifdef LOG_PID
6611         if ((x & LOG_PID) == LOG_PID)
6612                 *r |= Mono_Posix_SyslogOptions_LOG_PID;
6613 #endif /* ndef LOG_PID */
6614         return 0;
6615 }
6616
6617 int
6618 Mono_Posix_FromTimeval (struct Mono_Posix_Timeval *from, struct timeval *to)
6619 {
6620         _cnm_return_val_if_overflow (time_t, from->tv_sec, -1);
6621         _cnm_return_val_if_overflow (suseconds_t, from->tv_usec, -1);
6622
6623         memset (to, 0, sizeof(*to));
6624
6625         to->tv_sec  = from->tv_sec;
6626         to->tv_usec = from->tv_usec;
6627
6628         return 0;
6629 }
6630
6631
6632 int
6633 Mono_Posix_ToTimeval (struct timeval *from, struct Mono_Posix_Timeval *to)
6634 {
6635         _cnm_return_val_if_overflow (gint64, from->tv_sec, -1);
6636         _cnm_return_val_if_overflow (gint64, from->tv_usec, -1);
6637
6638         memset (to, 0, sizeof(*to));
6639
6640         to->tv_sec  = from->tv_sec;
6641         to->tv_usec = from->tv_usec;
6642
6643         return 0;
6644 }
6645
6646
6647 int
6648 Mono_Posix_FromTimezone (struct Mono_Posix_Timezone *from, struct timezone *to)
6649 {
6650         _cnm_return_val_if_overflow (int, from->tz_minuteswest, -1);
6651         _cnm_return_val_if_overflow (int, from->tz_dsttime, -1);
6652
6653         memset (to, 0, sizeof(*to));
6654
6655         to->tz_minuteswest = from->tz_minuteswest;
6656         to->tz_dsttime     = from->tz_dsttime;
6657
6658         return 0;
6659 }
6660
6661
6662 int
6663 Mono_Posix_ToTimezone (struct timezone *from, struct Mono_Posix_Timezone *to)
6664 {
6665         _cnm_return_val_if_overflow (int, from->tz_minuteswest, -1);
6666         _cnm_return_val_if_overflow (int, from->tz_dsttime, -1);
6667
6668         memset (to, 0, sizeof(*to));
6669
6670         to->tz_minuteswest = from->tz_minuteswest;
6671         to->tz_dsttime     = from->tz_dsttime;
6672
6673         return 0;
6674 }
6675
6676
6677 int Mono_Posix_FromWaitOptions (int x, int *r)
6678 {
6679         *r = 0;
6680         if ((x & Mono_Posix_WaitOptions_WNOHANG) == Mono_Posix_WaitOptions_WNOHANG)
6681 #ifdef WNOHANG
6682                 *r |= WNOHANG;
6683 #else /* def WNOHANG */
6684                 {errno = EINVAL; return -1;}
6685 #endif /* ndef WNOHANG */
6686         if ((x & Mono_Posix_WaitOptions_WUNTRACED) == Mono_Posix_WaitOptions_WUNTRACED)
6687 #ifdef WUNTRACED
6688                 *r |= WUNTRACED;
6689 #else /* def WUNTRACED */
6690                 {errno = EINVAL; return -1;}
6691 #endif /* ndef WUNTRACED */
6692         if (x == 0)
6693                 return 0;
6694         return 0;
6695 }
6696
6697 int Mono_Posix_ToWaitOptions (int x, int *r)
6698 {
6699         *r = 0;
6700         if (x == 0)
6701                 return 0;
6702 #ifdef WNOHANG
6703         if ((x & WNOHANG) == WNOHANG)
6704                 *r |= Mono_Posix_WaitOptions_WNOHANG;
6705 #endif /* ndef WNOHANG */
6706 #ifdef WUNTRACED
6707         if ((x & WUNTRACED) == WUNTRACED)
6708                 *r |= Mono_Posix_WaitOptions_WUNTRACED;
6709 #endif /* ndef WUNTRACED */
6710         return 0;
6711 }
6712
6713 int Mono_Posix_FromXattrFlags (int x, int *r)
6714 {
6715         *r = 0;
6716         if ((x & Mono_Posix_XattrFlags_XATTR_AUTO) == Mono_Posix_XattrFlags_XATTR_AUTO)
6717 #ifdef XATTR_AUTO
6718                 *r |= XATTR_AUTO;
6719 #else /* def XATTR_AUTO */
6720                 {errno = EINVAL; return -1;}
6721 #endif /* ndef XATTR_AUTO */
6722         if ((x & Mono_Posix_XattrFlags_XATTR_CREATE) == Mono_Posix_XattrFlags_XATTR_CREATE)
6723 #ifdef XATTR_CREATE
6724                 *r |= XATTR_CREATE;
6725 #else /* def XATTR_CREATE */
6726                 {errno = EINVAL; return -1;}
6727 #endif /* ndef XATTR_CREATE */
6728         if ((x & Mono_Posix_XattrFlags_XATTR_REPLACE) == Mono_Posix_XattrFlags_XATTR_REPLACE)
6729 #ifdef XATTR_REPLACE
6730                 *r |= XATTR_REPLACE;
6731 #else /* def XATTR_REPLACE */
6732                 {errno = EINVAL; return -1;}
6733 #endif /* ndef XATTR_REPLACE */
6734         if (x == 0)
6735                 return 0;
6736         return 0;
6737 }
6738
6739 int Mono_Posix_ToXattrFlags (int x, int *r)
6740 {
6741         *r = 0;
6742         if (x == 0)
6743                 return 0;
6744 #ifdef XATTR_AUTO
6745         if ((x & XATTR_AUTO) == XATTR_AUTO)
6746                 *r |= Mono_Posix_XattrFlags_XATTR_AUTO;
6747 #endif /* ndef XATTR_AUTO */
6748 #ifdef XATTR_CREATE
6749         if ((x & XATTR_CREATE) == XATTR_CREATE)
6750                 *r |= Mono_Posix_XattrFlags_XATTR_CREATE;
6751 #endif /* ndef XATTR_CREATE */
6752 #ifdef XATTR_REPLACE
6753         if ((x & XATTR_REPLACE) == XATTR_REPLACE)
6754                 *r |= Mono_Posix_XattrFlags_XATTR_REPLACE;
6755 #endif /* ndef XATTR_REPLACE */
6756         return 0;
6757 }
6758