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