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