Index: support/create-native-map.exe =================================================================== Cannot display: file marked as a binary type. svn:mime-type = application/octet-stream Property changes on: support/create-native-map.exe ___________________________________________________________________ Name: svn:mime-type + application/octet-stream Index: support/sys-mman.c =================================================================== --- support/sys-mman.c (revision 66730) +++ support/sys-mman.c (working copy) @@ -4,7 +4,7 @@ * Authors: * Jonathan Pryor (jonpryor@vt.edu) * - * Copyright (C) 2004 Jonathan Pryor + * Copyright (C) 2004-2006 Jonathan Pryor */ #define _XOPEN_SOURCE 600 @@ -27,7 +27,7 @@ mph_return_val_if_size_t_overflow (length, MAP_FAILED); mph_return_val_if_off_t_overflow (offset, MAP_FAILED); - if (Mono_Posix_FromMmapProt (prot, &_prot) == -1) + if (Mono_Posix_FromMmapProts (prot, &_prot) == -1) return MAP_FAILED; if (Mono_Posix_FromMmapFlags (flags, &_flags) == -1) return MAP_FAILED; @@ -49,7 +49,7 @@ int _prot; mph_return_if_size_t_overflow (len); - if (Mono_Posix_FromMmapProt (prot, &_prot) == -1) + if (Mono_Posix_FromMmapProts (prot, &_prot) == -1) return -1; return mprotect (start, (size_t) len, _prot); @@ -102,11 +102,11 @@ #endif /* def HAVE_MREMAP */ int -Mono_Posix_Syscall_mincore (void *start, mph_size_t length, void *vec) +Mono_Posix_Syscall_mincore (void *start, mph_size_t length, unsigned char *vec) { mph_return_if_size_t_overflow (length); - return mincore (start, (size_t) length, (unsigned char*) vec); + return mincore (start, (size_t) length, vec); } #ifdef HAVE_POSIX_MADVISE @@ -132,7 +132,7 @@ mph_return_if_size_t_overflow (size); mph_return_if_ssize_t_overflow (pgoff); - if (Mono_Posix_FromMmapProt (prot, &_prot) == -1) + if (Mono_Posix_FromMmapProts (prot, &_prot) == -1) return -1; if (Mono_Posix_FromMmapFlags (flags, &_flags) == -1) return -1; Index: support/sys-sendfile.c =================================================================== --- support/sys-sendfile.c (revision 66730) +++ support/sys-sendfile.c (working copy) @@ -10,6 +10,7 @@ #include #include +#include "map.h" #include "mph.h" #ifdef HAVE_SYS_SENDFILE_H Index: support/fcntl.c =================================================================== --- support/fcntl.c (revision 66730) +++ support/fcntl.c (working copy) @@ -4,7 +4,7 @@ * Authors: * Jonathan Pryor (jonpryor@vt.edu) * - * Copyright (C) 2004 Jonathan Pryor + * Copyright (C) 2004, 2006 Jonathan Pryor */ #ifndef _GNU_SOURCE @@ -22,14 +22,6 @@ G_BEGIN_DECLS -struct Mono_Posix_Flock { - gint16 l_type; - gint16 l_whence; - mph_off_t l_start; - mph_off_t l_len; - mph_pid_t l_pid; -}; - gint32 Mono_Posix_Syscall_fcntl (gint32 fd, gint32 cmd) { Index: support/string.c =================================================================== --- support/string.c (revision 66730) +++ support/string.c (working copy) @@ -9,6 +9,7 @@ #include +#include "map.h" #include "mph.h" G_BEGIN_DECLS Index: support/syslog.c =================================================================== --- support/syslog.c (revision 66730) +++ support/syslog.c (working copy) @@ -11,6 +11,7 @@ #include #include +#include "map.h" #include "mph.h" #include Index: support/stdlib.c =================================================================== --- support/stdlib.c (revision 66730) +++ support/stdlib.c (working copy) @@ -9,6 +9,7 @@ #include +#include "map.h" #include "mph.h" G_BEGIN_DECLS Index: support/stdio.c =================================================================== --- support/stdio.c (revision 66730) +++ support/stdio.c (working copy) @@ -4,13 +4,14 @@ * Authors: * Jonathan Pryor (jonpryor@vt.edu) * - * Copyright (C) 2004-2005 Jonathan Pryor + * Copyright (C) 2004-2006 Jonathan Pryor */ #include #include #include +#include "map.h" #include "mph.h" G_BEGIN_DECLS @@ -30,7 +31,7 @@ #endif /* ndef PLATFORM_WIN32 */ mph_size_t -Mono_Posix_Stdlib_fread (void *ptr, mph_size_t size, mph_size_t nmemb, void *stream) +Mono_Posix_Stdlib_fread (unsigned char *ptr, mph_size_t size, mph_size_t nmemb, void *stream) { mph_return_if_size_t_overflow (size); mph_return_if_size_t_overflow (nmemb); @@ -39,7 +40,7 @@ } mph_size_t -Mono_Posix_Stdlib_fwrite (void *ptr, mph_size_t size, mph_size_t nmemb, void *stream) +Mono_Posix_Stdlib_fwrite (unsigned char *ptr, mph_size_t size, mph_size_t nmemb, void *stream) { mph_return_if_size_t_overflow (size); mph_return_if_size_t_overflow (nmemb); Index: support/utime.c =================================================================== --- support/utime.c (revision 66730) +++ support/utime.c (working copy) @@ -4,21 +4,17 @@ * Authors: * Jonathan Pryor (jonpryor@vt.edu) * - * Copyright (C) 2004 Jonathan Pryor + * Copyright (C) 2004-2006 Jonathan Pryor */ #include #include +#include "map.h" #include "mph.h" G_BEGIN_DECLS -struct Mono_Posix_Utimbuf { - /* time_t */ mph_time_t actime; /* access time */ - /* time_t */ mph_time_t modtime; /* modification time */ -}; - gint32 Mono_Posix_Syscall_utime (const char *filename, struct Mono_Posix_Utimbuf *buf, int use_buf) Index: support/dirent.c =================================================================== --- support/dirent.c (revision 66730) +++ support/dirent.c (working copy) @@ -13,18 +13,11 @@ #include #include +#include "map.h" #include "mph.h" G_BEGIN_DECLS -struct Mono_Posix_Syscall__Dirent { - /* ino_t */ mph_ino_t d_ino; - /* off_t */ mph_off_t d_off; - /* ushort */ unsigned short d_reclen; - /* byte */ unsigned char d_type; - /* string */ char *d_name; -}; - gint32 Mono_Posix_Syscall_seekdir (void *dir, mph_off_t offset) { Index: support/sys-stat.c =================================================================== --- support/sys-stat.c (revision 66730) +++ support/sys-stat.c (working copy) @@ -4,7 +4,7 @@ * Authors: * Jonathan Pryor (jonpryor@vt.edu) * - * Copyright (C) 2004 Jonathan Pryor + * Copyright (C) 2004-2006 Jonathan Pryor */ #ifndef _GNU_SOURCE @@ -22,47 +22,6 @@ G_BEGIN_DECLS -struct Mono_Posix_Stat { - /* dev_t */ mph_dev_t st_dev; /* device */ - /* ino_t */ mph_ino_t st_ino; /* inode */ - /* mode_t */ guint32 st_mode; /* protection */ - guint32 _padding_; /* structure padding */ - /* nlink_t */ mph_nlink_t st_nlink; /* number of hard links */ - /* uid_t */ mph_uid_t st_uid; /* user ID of owner */ - /* gid_t */ mph_gid_t st_gid; /* group ID of owner */ - /* dev_t */ mph_dev_t st_rdev; /* device type (if inode device) */ - /* off_t */ mph_off_t st_size; /* total size, in bytes */ - /* blksize_t */ mph_blksize_t st_blksize; /* blocksize for filesystem I/O */ - /* blkcnt_t */ mph_blkcnt_t st_blocks; /* number of blocks allocated */ - - /* st_atime, st_mtime, and st_ctime are macros (!), so use a slightly - * different name to appease CPP */ - - /* time_t */ mph_time_t st_atime_; /* time of last access */ - /* time_t */ mph_time_t st_mtime_; /* time of last modification */ - /* time_t */ mph_time_t st_ctime_; /* time of last status change */ -}; - -static int -copy_stat (struct Mono_Posix_Stat *to, struct stat *from) -{ - if (Mono_Posix_ToFilePermissions (from->st_mode, &to->st_mode) == -1) - return -1; - to->st_dev = from->st_dev; - to->st_ino = from->st_ino; - to->st_nlink = from->st_nlink; - to->st_uid = from->st_uid; - to->st_gid = from->st_gid; - to->st_rdev = from->st_rdev; - to->st_size = from->st_size; - to->st_blksize = from->st_blksize; - to->st_blocks = from->st_blocks; - to->st_atime_ = from->st_atime; - to->st_mtime_ = from->st_mtime; - to->st_ctime_ = from->st_ctime; - return 0; -} - gint32 Mono_Posix_Syscall_stat (const char *file_name, struct Mono_Posix_Stat *buf) { @@ -74,7 +33,7 @@ return -1; } r = stat (file_name, &_buf); - if (r != -1 && copy_stat (buf, &_buf) == -1) + if (r != -1 && Mono_Posix_ToStat (&_buf, buf) == -1) r = -1; return r; } @@ -90,7 +49,7 @@ return -1; } r = fstat (filedes, &_buf); - if (r != -1 && copy_stat (buf, &_buf) == -1) + if (r != -1 && Mono_Posix_ToStat (&_buf, buf) == -1) r = -1; return r; } @@ -106,7 +65,7 @@ return -1; } r = lstat (file_name, &_buf); - if (r != -1 && copy_stat (buf, &_buf) == -1) + if (r != -1 && Mono_Posix_ToStat (&_buf, buf) == -1) r = -1; return r; } Index: support/grp.c =================================================================== --- support/grp.c (revision 66730) +++ support/grp.c (working copy) @@ -16,19 +16,11 @@ #include #include /* for setgroups on Mac OS X */ +#include "map.h" #include "mph.h" G_BEGIN_DECLS -struct Mono_Posix_Syscall__Group { - /* string */ char *gr_name; - /* string */ char *gr_passwd; - /* gid_t */ mph_gid_t gr_gid; - /* int */ int _gr_nmem_; - /* string */ char **gr_mem; - /* string */ char *_gr_buf_; /* holds all but gr_mem */ -}; - static void count_members (char **gr_mem, int *count, size_t *mem) { @@ -56,7 +48,7 @@ { size_t nlen, plen, buflen; int i, count; - char *cur; + char *cur, **to_mem; to->gr_gid = from->gr_gid; @@ -83,7 +75,7 @@ to->_gr_nmem_ = count; cur = to->_gr_buf_ = (char*) malloc (buflen); - to->gr_mem = (char **) malloc (sizeof(char*)*(count+1)); + to_mem = to->gr_mem = malloc (sizeof(char*)*(count+1)); if (to->_gr_buf_ == NULL || to->gr_mem == NULL) { free (to->_gr_buf_); free (to->gr_mem); @@ -96,10 +88,10 @@ cur += (plen + 1); for (i = 0; i != count; ++i) { - to->gr_mem[i] = strcpy (cur, from->gr_mem[i]); + to_mem [i] = strcpy (cur, from->gr_mem[i]); cur += (strlen (from->gr_mem[i])+1); } - to->gr_mem[i] = NULL; + to_mem [i] = NULL; return 0; } Index: support/mph.h =================================================================== --- support/mph.h (revision 66730) +++ support/mph.h (working copy) @@ -35,8 +35,6 @@ #include /* for SIZE_MAX */ #endif -#include "map-icalls.h" - #if __APPLE__ || __BSD__ || __FreeBSD__ #define MPH_ON_BSD #endif Index: support/time.c =================================================================== --- support/time.c (revision 66730) +++ support/time.c (working copy) @@ -11,6 +11,7 @@ #include #include +#include "map.h" #include "mph.h" #include Index: support/fstab.c =================================================================== --- support/fstab.c (revision 66730) +++ support/fstab.c (working copy) @@ -13,6 +13,7 @@ #include #include +#include "map.h" #include "mph.h" #if defined (HAVE_CHECKLIST_H) @@ -27,18 +28,6 @@ G_BEGIN_DECLS -struct Mono_Posix_Syscall__Fstab { - char *fs_spec; /* block device name */ - char *fs_file; /* mount point */ - char *fs_vfstype; /* filesystem type */ - char *fs_mntops; /* mount options */ - char *fs_type; /* rw/rq/ro/sw/xx option */ - int fs_freq; /* dump frequency, in days */ - int fs_passno; /* pass number on parallel dump */ - - char *_fs_buf_; -}; - #ifdef HAVE_CHECKLIST_H typedef struct checklist mph_fstab; @@ -245,10 +234,11 @@ #if defined (HAVE_FSTAB_H) || defined (HAVE_CHECKPOINT_H) || defined (HAVE_SYS_VFSTAB_H) -void +int Mono_Posix_Syscall_endfsent (void) { endfsent (); + return 0; } gint32 Index: support/sys-statvfs.c =================================================================== --- support/sys-statvfs.c (revision 66730) +++ support/sys-statvfs.c (working copy) @@ -4,7 +4,7 @@ * Authors: * Jonathan Pryor (jonpryor@vt.edu) * - * Copyright (C) 2004 Jonathan Pryor + * Copyright (C) 2004-2006 Jonathan Pryor */ #include @@ -27,36 +27,52 @@ G_BEGIN_DECLS -struct Mono_Posix_Statvfs { - guint64 f_bsize; /* file system block size */ - guint64 f_frsize; /* fragment size */ - mph_fsblkcnt_t f_blocks; /* size of fs in f_frsize units */ - mph_fsblkcnt_t f_bfree; /* # free blocks */ - mph_fsblkcnt_t f_bavail; /* # free blocks for non-root */ - mph_fsfilcnt_t f_files; /* # inodes */ - mph_fsfilcnt_t f_ffree; /* # free inodes */ - mph_fsfilcnt_t f_favail; /* # free inodes for non-root */ - guint64 f_fsid; /* file system id */ - guint64 f_flag; /* mount flags */ - guint64 f_namemax; /* maximum filename length */ -}; - #ifdef HAVE_SYS_STATVFS_H -static void -copy_statvfs (struct Mono_Posix_Statvfs *to, struct statvfs *from) +int +Mono_Posix_ToStatvfs (void *_from, struct Mono_Posix_Statvfs *to) { - to->f_bsize = from->f_bsize; - to->f_frsize = from->f_frsize; - to->f_blocks = from->f_blocks; - to->f_bfree = from->f_bfree; - to->f_bavail = from->f_bavail; - to->f_files = from->f_files; - to->f_ffree = from->f_ffree; - to->f_favail = from->f_favail; - to->f_fsid = from->f_fsid; - Mono_Posix_ToMountFlags (from->f_flag, &to->f_flag); - to->f_namemax = from->f_namemax; + struct statvfs *from = _from; + + to->f_bsize = from->f_bsize; + to->f_frsize = from->f_frsize; + to->f_blocks = from->f_blocks; + to->f_bfree = from->f_bfree; + to->f_bavail = from->f_bavail; + to->f_files = from->f_files; + to->f_ffree = from->f_ffree; + to->f_favail = from->f_favail; + to->f_fsid = from->f_fsid; + to->f_namemax = from->f_namemax; + + if (Mono_Posix_ToMountFlags (from->f_flag, &to->f_flag) != 0) + return -1; + + return 0; } + +int +Mono_Posix_FromStatvfs (struct Mono_Posix_Statvfs *from, void *_to) +{ + struct statvfs *to = _to; + guint64 flag; + + to->f_bsize = from->f_bsize; + to->f_frsize = from->f_frsize; + to->f_blocks = from->f_blocks; + to->f_bfree = from->f_bfree; + to->f_bavail = from->f_bavail; + to->f_files = from->f_files; + to->f_ffree = from->f_ffree; + to->f_favail = from->f_favail; + to->f_fsid = from->f_fsid; + to->f_namemax = from->f_namemax; + + if (Mono_Posix_FromMountFlags (from->f_flag, &flag) != 0) + return -1; + to->f_flag = flag; + + return 0; +} #endif /* ndef HAVE_SYS_STATVFS_H */ /* @@ -76,7 +92,7 @@ } if ((r = statvfs (path, &s)) == 0) - copy_statvfs (buf, &s); + r = Mono_Posix_ToStatvfs (&s, buf); return r; } @@ -95,7 +111,7 @@ } if ((r = fstatvfs (fd, &s)) == 0) - copy_statvfs (buf, &s); + r = Mono_Posix_ToStatvfs (&s, buf); return r; } @@ -108,23 +124,54 @@ */ #if (defined (HAVE_STATFS) || defined (HAVE_FSTATFS)) && !defined (HAVE_STATVFS) -static void -copy_statfs (struct Mono_Posix_Statvfs *to, struct statfs *from) +int +Mono_Posix_ToStatvfs (void *_from, struct Mono_Posix_Statvfs *to) { - to->f_bsize = from->f_bsize; - to->f_frsize = from->f_bsize; - to->f_blocks = from->f_blocks; - to->f_bfree = from->f_bfree; - to->f_bavail = from->f_bavail; - to->f_files = from->f_files; - to->f_ffree = from->f_ffree; - to->f_favail = from->f_ffree; /* OSX doesn't have f_avail */ - Mono_Posix_ToMountFlags (from->f_flags, &to->f_flag); + struct statfs *from = _from; + + to->f_bsize = from->f_bsize; + to->f_frsize = from->f_bsize; + to->f_blocks = from->f_blocks; + to->f_bfree = from->f_bfree; + to->f_bavail = from->f_bavail; + to->f_files = from->f_files; + to->f_ffree = from->f_ffree; + to->f_favail = from->f_ffree; /* OSX doesn't have f_avail */ + // from->f_fsid is an int32[2], to->f_fsid is a uint64, // so this shouldn't lose anything. memcpy (&to->f_fsid, &from->f_fsid, sizeof(to->f_fsid)); + + if (Mono_Posix_ToMountFlags (from->f_flags, &to->f_flag) != 0) + return -1; + + return 0; } +int +Mono_Posix_FromStatvfs (struct Mono_Posix_Statvfs *from, void *to) +{ + struct statfs *to = _to; + + to->f_bsize = from->f_bsize; + to->f_frsize = from->f_bsize; + to->f_blocks = from->f_blocks; + to->f_bfree = from->f_bfree; + to->f_bavail = from->f_bavail; + to->f_files = from->f_files; + to->f_ffree = from->f_ffree; + to->f_favail = from->f_ffree; /* OSX doesn't have f_avail */ + + // from->f_fsid is an int32[2], to->f_fsid is a uint64, + // so this shouldn't lose anything. + memcpy (&to->f_fsid, &from->f_fsid, sizeof(to->f_fsid)); + + if (Mono_Posix_FromMountFlags (from->f_flags, &to->f_flag) != 0) + return -1; + + return 0; +} + static void set_namemax (const char *path, struct Mono_Posix_Statvfs *buf) { @@ -150,8 +197,8 @@ return -1; } - if ((r = statfs (path, &s)) == 0) { - copy_statfs (buf, &s); + if ((r = statfs (path, &s)) == 0 && + (r = Mono_Posix_ToStatvfs (&s, buf)) == 0) { set_namemax (path, buf); } @@ -171,8 +218,8 @@ return -1; } - if ((r = fstatfs (fd, &s)) == 0) { - copy_statfs (buf, &s); + if ((r = statfs (path, &s)) == 0 && + (r = Mono_Posix_ToStatvfs (&s, buf)) == 0) { set_fnamemax (fd, buf); } Index: support/unistd.c =================================================================== --- support/unistd.c (revision 66730) +++ support/unistd.c (working copy) @@ -4,7 +4,7 @@ * Authors: * Jonathan Pryor (jonpryor@vt.edu) * - * Copyright (C) 2004-2005 Jonathan Pryor + * Copyright (C) 2004-2006 Jonathan Pryor */ #ifndef _GNU_SOURCE @@ -227,12 +227,13 @@ return lockf (fd, cmd, (off_t) len); } -void +int Mono_Posix_Syscall_swab (void *from, void *to, mph_ssize_t n) { if (mph_have_long_overflow (n)) - return; + return -1; swab (from, to, (ssize_t) n); + return 0; } int Index: support/ChangeLog =================================================================== --- support/ChangeLog (revision 66730) +++ support/ChangeLog (working copy) @@ -1,3 +1,21 @@ +2006-10-18 Jonathan Pryor + + * dirent.c, errno.c, fcntl.c, fstab.c, grp.c, macros.c, pwd.c, signal.c, + stdio.c, stdlib.c, string.c, sys-mman.c, sys-sendfile.c, sys-stat.c, + sys-statvfs.c, sys-time.c, sys-xattr.c syslog.c, time.c, unistd.c, + utime.c: Remove structure definitions, and use the + create-native-map generated definitions within map.h. Update function + prototypes to match current map.h declarations. + * map.c, map.h: Flush (current create-native-map output). + * mph.h: Don't include "map-icalls.h"; "icalls" are now in map.h. + * create-native-map.exe: Added; cached version of create-native-map.exe + used to update map.c, map.h. (create-native-map.exe source within + mono-tools/create-native-map.) + * Makefile.am: Added update-create-native-map target to update + create-native-map.exe using pkg-config & the create-native-map.pc package. + Use create-native-map.exe to generate map.* files instead of make-map.exe. + * sys-statvfs.c: Add Mono_Posix_ToStatvfs, Mono_Posix_FromStatvfs exports. + 2006-09-15 Jonathan Pryor * Makefile.am: Remove CRYPT_LIBS use; we no longer rely on libcrypt. Index: support/sys-time.c =================================================================== --- support/sys-time.c (revision 66730) +++ support/sys-time.c (working copy) @@ -16,16 +16,6 @@ G_BEGIN_DECLS -struct Mono_Posix_Timeval { - /* time_t */ mph_time_t tv_sec; /* seconds */ - /* suseconds_t */ gint64 tv_usec; /* microseconds */ -}; - -struct Mono_Posix_Timezone { - int tz_minuteswest; /* minutes W of Greenwich */ - int tz_dsttime; /* ignored */ -}; - gint32 Mono_Posix_Syscall_gettimeofday ( struct Mono_Posix_Timeval *tv, Index: support/map.c =================================================================== --- support/map.c (revision 66730) +++ support/map.c (working copy) @@ -1,1898 +1,147 @@ /* - * This file was automatically generated by make-map from ../../mcs/class/lib/default/Mono.Posix.dll. + * This file was automatically generated by create-native-map from ../../mcs/class/lib/net_2_0/Mono.Posix.dll. * * DO NOT MODIFY. */ +#ifdef HAVE_CONFIG_H #include +#endif /* ndef HAVE_CONFIG_H */ -#include "map.h" +#include +#include +/* + * Implementation Macros + */ #ifndef _GNU_SOURCE #define _GNU_SOURCE #endif /* ndef _GNU_SOURCE */ + #ifndef _XOPEN_SOURCE #define _XOPEN_SOURCE #endif /* ndef _XOPEN_SOURCE */ + + +/* + * Implementation Includes + */ #include #include +#include #ifdef HAVE_SYS_POLL_H #include -#endif +#endif /* ndef HAVE_SYS_POLL_H */ #ifdef HAVE_SYS_WAIT_H #include -#endif +#endif /* ndef HAVE_SYS_WAIT_H */ #ifdef HAVE_SYS_STATVFS_H #include -#endif +#endif /* ndef HAVE_SYS_STATVFS_H */ #ifdef HAVE_SYS_XATTR_H #include -#endif +#endif /* ndef HAVE_SYS_XATTR_H */ #ifdef HAVE_SYS_MMAN_H #include -#endif +#endif /* ndef HAVE_SYS_MMAN_H */ #include #include #include #ifdef HAVE_POLL_H #include -#endif +#endif /* ndef HAVE_POLL_H */ #ifdef HAVE_GRP_H #include -#endif +#endif /* ndef HAVE_GRP_H */ #include #ifdef HAVE_SYSLOG_H #include -#endif +#endif /* ndef HAVE_SYSLOG_H */ +#include +#include -int Mono_Posix_FromAccessMode (int x, int *r) -{ - *r = 0; - if (x == 0) - return 0; - if ((x & Mono_Posix_AccessMode_F_OK) == Mono_Posix_AccessMode_F_OK) -#ifdef F_OK - *r |= F_OK; -#else /* def F_OK */ - {errno = EINVAL; return -1;} -#endif /* ndef F_OK */ - if ((x & Mono_Posix_AccessMode_R_OK) == Mono_Posix_AccessMode_R_OK) -#ifdef R_OK - *r |= R_OK; -#else /* def R_OK */ - {errno = EINVAL; return -1;} -#endif /* ndef R_OK */ - if ((x & Mono_Posix_AccessMode_W_OK) == Mono_Posix_AccessMode_W_OK) -#ifdef W_OK - *r |= W_OK; -#else /* def W_OK */ - {errno = EINVAL; return -1;} -#endif /* ndef W_OK */ - if ((x & Mono_Posix_AccessMode_X_OK) == Mono_Posix_AccessMode_X_OK) -#ifdef X_OK - *r |= X_OK; -#else /* def X_OK */ - {errno = EINVAL; return -1;} -#endif /* ndef X_OK */ - return 0; -} +#include "map.h" -int Mono_Posix_ToAccessMode (int x, int *r) -{ - *r = 0; - if (x == 0) - return 0; -#ifdef F_OK - if ((x & F_OK) == F_OK) - *r |= Mono_Posix_AccessMode_F_OK; -#endif /* ndef F_OK */ -#ifdef R_OK - if ((x & R_OK) == R_OK) - *r |= Mono_Posix_AccessMode_R_OK; -#endif /* ndef R_OK */ -#ifdef W_OK - if ((x & W_OK) == W_OK) - *r |= Mono_Posix_AccessMode_W_OK; -#endif /* ndef W_OK */ -#ifdef X_OK - if ((x & X_OK) == X_OK) - *r |= Mono_Posix_AccessMode_X_OK; -#endif /* ndef X_OK */ - return 0; -} +#include /* errno, EOVERFLOW */ +#include /* g* types, g_assert_not_reached() */ -int Mono_Posix_FromConfStr (int x, int *r) -{ - *r = 0; - if (x == 0) - return 0; - if (x == Mono_Posix_ConfStr__CS_GNU_LIBC_VERSION) -#ifdef _CS_GNU_LIBC_VERSION - {*r = _CS_GNU_LIBC_VERSION; return 0;} -#else /* def _CS_GNU_LIBC_VERSION */ - {errno = EINVAL; return -1;} -#endif /* ndef _CS_GNU_LIBC_VERSION */ - if (x == Mono_Posix_ConfStr__CS_GNU_LIBPTHREAD_VERSION) -#ifdef _CS_GNU_LIBPTHREAD_VERSION - {*r = _CS_GNU_LIBPTHREAD_VERSION; return 0;} -#else /* def _CS_GNU_LIBPTHREAD_VERSION */ - {errno = EINVAL; return -1;} -#endif /* ndef _CS_GNU_LIBPTHREAD_VERSION */ - if (x == Mono_Posix_ConfStr__CS_LFS64_CFLAGS) -#ifdef _CS_LFS64_CFLAGS - {*r = _CS_LFS64_CFLAGS; return 0;} -#else /* def _CS_LFS64_CFLAGS */ - {errno = EINVAL; return -1;} -#endif /* ndef _CS_LFS64_CFLAGS */ - if (x == Mono_Posix_ConfStr__CS_LFS64_LDFLAGS) -#ifdef _CS_LFS64_LDFLAGS - {*r = _CS_LFS64_LDFLAGS; return 0;} -#else /* def _CS_LFS64_LDFLAGS */ - {errno = EINVAL; return -1;} -#endif /* ndef _CS_LFS64_LDFLAGS */ - if (x == Mono_Posix_ConfStr__CS_LFS64_LIBS) -#ifdef _CS_LFS64_LIBS - {*r = _CS_LFS64_LIBS; return 0;} -#else /* def _CS_LFS64_LIBS */ - {errno = EINVAL; return -1;} -#endif /* ndef _CS_LFS64_LIBS */ - if (x == Mono_Posix_ConfStr__CS_LFS64_LINTFLAGS) -#ifdef _CS_LFS64_LINTFLAGS - {*r = _CS_LFS64_LINTFLAGS; return 0;} -#else /* def _CS_LFS64_LINTFLAGS */ - {errno = EINVAL; return -1;} -#endif /* ndef _CS_LFS64_LINTFLAGS */ - if (x == Mono_Posix_ConfStr__CS_LFS_CFLAGS) -#ifdef _CS_LFS_CFLAGS - {*r = _CS_LFS_CFLAGS; return 0;} -#else /* def _CS_LFS_CFLAGS */ - {errno = EINVAL; return -1;} -#endif /* ndef _CS_LFS_CFLAGS */ - if (x == Mono_Posix_ConfStr__CS_LFS_LDFLAGS) -#ifdef _CS_LFS_LDFLAGS - {*r = _CS_LFS_LDFLAGS; return 0;} -#else /* def _CS_LFS_LDFLAGS */ - {errno = EINVAL; return -1;} -#endif /* ndef _CS_LFS_LDFLAGS */ - if (x == Mono_Posix_ConfStr__CS_LFS_LIBS) -#ifdef _CS_LFS_LIBS - {*r = _CS_LFS_LIBS; return 0;} -#else /* def _CS_LFS_LIBS */ - {errno = EINVAL; return -1;} -#endif /* ndef _CS_LFS_LIBS */ - if (x == Mono_Posix_ConfStr__CS_LFS_LINTFLAGS) -#ifdef _CS_LFS_LINTFLAGS - {*r = _CS_LFS_LINTFLAGS; return 0;} -#else /* def _CS_LFS_LINTFLAGS */ - {errno = EINVAL; return -1;} -#endif /* ndef _CS_LFS_LINTFLAGS */ - if (x == Mono_Posix_ConfStr__CS_PATH) -#ifdef _CS_PATH - {*r = _CS_PATH; return 0;} -#else /* def _CS_PATH */ - {errno = EINVAL; return -1;} -#endif /* ndef _CS_PATH */ - if (x == Mono_Posix_ConfStr__CS_POSIX_V6_ILP32_OFF32_CFLAGS) -#ifdef _CS_POSIX_V6_ILP32_OFF32_CFLAGS - {*r = _CS_POSIX_V6_ILP32_OFF32_CFLAGS; return 0;} -#else /* def _CS_POSIX_V6_ILP32_OFF32_CFLAGS */ - {errno = EINVAL; return -1;} -#endif /* ndef _CS_POSIX_V6_ILP32_OFF32_CFLAGS */ - if (x == Mono_Posix_ConfStr__CS_POSIX_V6_ILP32_OFF32_LDFLAGS) -#ifdef _CS_POSIX_V6_ILP32_OFF32_LDFLAGS - {*r = _CS_POSIX_V6_ILP32_OFF32_LDFLAGS; return 0;} -#else /* def _CS_POSIX_V6_ILP32_OFF32_LDFLAGS */ - {errno = EINVAL; return -1;} -#endif /* ndef _CS_POSIX_V6_ILP32_OFF32_LDFLAGS */ - if (x == Mono_Posix_ConfStr__CS_POSIX_V6_ILP32_OFF32_LIBS) -#ifdef _CS_POSIX_V6_ILP32_OFF32_LIBS - {*r = _CS_POSIX_V6_ILP32_OFF32_LIBS; return 0;} -#else /* def _CS_POSIX_V6_ILP32_OFF32_LIBS */ - {errno = EINVAL; return -1;} -#endif /* ndef _CS_POSIX_V6_ILP32_OFF32_LIBS */ - if (x == Mono_Posix_ConfStr__CS_POSIX_V6_ILP32_OFF32_LINTFLAGS) -#ifdef _CS_POSIX_V6_ILP32_OFF32_LINTFLAGS - {*r = _CS_POSIX_V6_ILP32_OFF32_LINTFLAGS; return 0;} -#else /* def _CS_POSIX_V6_ILP32_OFF32_LINTFLAGS */ - {errno = EINVAL; return -1;} -#endif /* ndef _CS_POSIX_V6_ILP32_OFF32_LINTFLAGS */ - if (x == Mono_Posix_ConfStr__CS_POSIX_V6_ILP32_OFFBIG_CFLAGS) -#ifdef _CS_POSIX_V6_ILP32_OFFBIG_CFLAGS - {*r = _CS_POSIX_V6_ILP32_OFFBIG_CFLAGS; return 0;} -#else /* def _CS_POSIX_V6_ILP32_OFFBIG_CFLAGS */ - {errno = EINVAL; return -1;} -#endif /* ndef _CS_POSIX_V6_ILP32_OFFBIG_CFLAGS */ - if (x == Mono_Posix_ConfStr__CS_POSIX_V6_ILP32_OFFBIG_LDFLAGS) -#ifdef _CS_POSIX_V6_ILP32_OFFBIG_LDFLAGS - {*r = _CS_POSIX_V6_ILP32_OFFBIG_LDFLAGS; return 0;} -#else /* def _CS_POSIX_V6_ILP32_OFFBIG_LDFLAGS */ - {errno = EINVAL; return -1;} -#endif /* ndef _CS_POSIX_V6_ILP32_OFFBIG_LDFLAGS */ - if (x == Mono_Posix_ConfStr__CS_POSIX_V6_ILP32_OFFBIG_LIBS) -#ifdef _CS_POSIX_V6_ILP32_OFFBIG_LIBS - {*r = _CS_POSIX_V6_ILP32_OFFBIG_LIBS; return 0;} -#else /* def _CS_POSIX_V6_ILP32_OFFBIG_LIBS */ - {errno = EINVAL; return -1;} -#endif /* ndef _CS_POSIX_V6_ILP32_OFFBIG_LIBS */ - if (x == Mono_Posix_ConfStr__CS_POSIX_V6_ILP32_OFFBIG_LINTFLAGS) -#ifdef _CS_POSIX_V6_ILP32_OFFBIG_LINTFLAGS - {*r = _CS_POSIX_V6_ILP32_OFFBIG_LINTFLAGS; return 0;} -#else /* def _CS_POSIX_V6_ILP32_OFFBIG_LINTFLAGS */ - {errno = EINVAL; return -1;} -#endif /* ndef _CS_POSIX_V6_ILP32_OFFBIG_LINTFLAGS */ - if (x == Mono_Posix_ConfStr__CS_POSIX_V6_LP64_OFF64_CFLAGS) -#ifdef _CS_POSIX_V6_LP64_OFF64_CFLAGS - {*r = _CS_POSIX_V6_LP64_OFF64_CFLAGS; return 0;} -#else /* def _CS_POSIX_V6_LP64_OFF64_CFLAGS */ - {errno = EINVAL; return -1;} -#endif /* ndef _CS_POSIX_V6_LP64_OFF64_CFLAGS */ - if (x == Mono_Posix_ConfStr__CS_POSIX_V6_LP64_OFF64_LDFLAGS) -#ifdef _CS_POSIX_V6_LP64_OFF64_LDFLAGS - {*r = _CS_POSIX_V6_LP64_OFF64_LDFLAGS; return 0;} -#else /* def _CS_POSIX_V6_LP64_OFF64_LDFLAGS */ - {errno = EINVAL; return -1;} -#endif /* ndef _CS_POSIX_V6_LP64_OFF64_LDFLAGS */ - if (x == Mono_Posix_ConfStr__CS_POSIX_V6_LP64_OFF64_LIBS) -#ifdef _CS_POSIX_V6_LP64_OFF64_LIBS - {*r = _CS_POSIX_V6_LP64_OFF64_LIBS; return 0;} -#else /* def _CS_POSIX_V6_LP64_OFF64_LIBS */ - {errno = EINVAL; return -1;} -#endif /* ndef _CS_POSIX_V6_LP64_OFF64_LIBS */ - if (x == Mono_Posix_ConfStr__CS_POSIX_V6_LP64_OFF64_LINTFLAGS) -#ifdef _CS_POSIX_V6_LP64_OFF64_LINTFLAGS - {*r = _CS_POSIX_V6_LP64_OFF64_LINTFLAGS; return 0;} -#else /* def _CS_POSIX_V6_LP64_OFF64_LINTFLAGS */ - {errno = EINVAL; return -1;} -#endif /* ndef _CS_POSIX_V6_LP64_OFF64_LINTFLAGS */ - if (x == Mono_Posix_ConfStr__CS_POSIX_V6_LPBIG_OFFBIG_CFLAGS) -#ifdef _CS_POSIX_V6_LPBIG_OFFBIG_CFLAGS - {*r = _CS_POSIX_V6_LPBIG_OFFBIG_CFLAGS; return 0;} -#else /* def _CS_POSIX_V6_LPBIG_OFFBIG_CFLAGS */ - {errno = EINVAL; return -1;} -#endif /* ndef _CS_POSIX_V6_LPBIG_OFFBIG_CFLAGS */ - if (x == Mono_Posix_ConfStr__CS_POSIX_V6_LPBIG_OFFBIG_LDFLAGS) -#ifdef _CS_POSIX_V6_LPBIG_OFFBIG_LDFLAGS - {*r = _CS_POSIX_V6_LPBIG_OFFBIG_LDFLAGS; return 0;} -#else /* def _CS_POSIX_V6_LPBIG_OFFBIG_LDFLAGS */ - {errno = EINVAL; return -1;} -#endif /* ndef _CS_POSIX_V6_LPBIG_OFFBIG_LDFLAGS */ - if (x == Mono_Posix_ConfStr__CS_POSIX_V6_LPBIG_OFFBIG_LIBS) -#ifdef _CS_POSIX_V6_LPBIG_OFFBIG_LIBS - {*r = _CS_POSIX_V6_LPBIG_OFFBIG_LIBS; return 0;} -#else /* def _CS_POSIX_V6_LPBIG_OFFBIG_LIBS */ - {errno = EINVAL; return -1;} -#endif /* ndef _CS_POSIX_V6_LPBIG_OFFBIG_LIBS */ - if (x == Mono_Posix_ConfStr__CS_POSIX_V6_LPBIG_OFFBIG_LINTFLAGS) -#ifdef _CS_POSIX_V6_LPBIG_OFFBIG_LINTFLAGS - {*r = _CS_POSIX_V6_LPBIG_OFFBIG_LINTFLAGS; return 0;} -#else /* def _CS_POSIX_V6_LPBIG_OFFBIG_LINTFLAGS */ - {errno = EINVAL; return -1;} -#endif /* ndef _CS_POSIX_V6_LPBIG_OFFBIG_LINTFLAGS */ - if (x == Mono_Posix_ConfStr__CS_V6_WIDTH_RESTRICTED_ENVS) -#ifdef _CS_V6_WIDTH_RESTRICTED_ENVS - {*r = _CS_V6_WIDTH_RESTRICTED_ENVS; return 0;} -#else /* def _CS_V6_WIDTH_RESTRICTED_ENVS */ - {errno = EINVAL; return -1;} -#endif /* ndef _CS_V6_WIDTH_RESTRICTED_ENVS */ - if (x == Mono_Posix_ConfStr__CS_XBS5_ILP32_OFF32_CFLAGS) -#ifdef _CS_XBS5_ILP32_OFF32_CFLAGS - {*r = _CS_XBS5_ILP32_OFF32_CFLAGS; return 0;} -#else /* def _CS_XBS5_ILP32_OFF32_CFLAGS */ - {errno = EINVAL; return -1;} -#endif /* ndef _CS_XBS5_ILP32_OFF32_CFLAGS */ - if (x == Mono_Posix_ConfStr__CS_XBS5_ILP32_OFF32_LDFLAGS) -#ifdef _CS_XBS5_ILP32_OFF32_LDFLAGS - {*r = _CS_XBS5_ILP32_OFF32_LDFLAGS; return 0;} -#else /* def _CS_XBS5_ILP32_OFF32_LDFLAGS */ - {errno = EINVAL; return -1;} -#endif /* ndef _CS_XBS5_ILP32_OFF32_LDFLAGS */ - if (x == Mono_Posix_ConfStr__CS_XBS5_ILP32_OFF32_LIBS) -#ifdef _CS_XBS5_ILP32_OFF32_LIBS - {*r = _CS_XBS5_ILP32_OFF32_LIBS; return 0;} -#else /* def _CS_XBS5_ILP32_OFF32_LIBS */ - {errno = EINVAL; return -1;} -#endif /* ndef _CS_XBS5_ILP32_OFF32_LIBS */ - if (x == Mono_Posix_ConfStr__CS_XBS5_ILP32_OFF32_LINTFLAGS) -#ifdef _CS_XBS5_ILP32_OFF32_LINTFLAGS - {*r = _CS_XBS5_ILP32_OFF32_LINTFLAGS; return 0;} -#else /* def _CS_XBS5_ILP32_OFF32_LINTFLAGS */ - {errno = EINVAL; return -1;} -#endif /* ndef _CS_XBS5_ILP32_OFF32_LINTFLAGS */ - if (x == Mono_Posix_ConfStr__CS_XBS5_ILP32_OFFBIG_CFLAGS) -#ifdef _CS_XBS5_ILP32_OFFBIG_CFLAGS - {*r = _CS_XBS5_ILP32_OFFBIG_CFLAGS; return 0;} -#else /* def _CS_XBS5_ILP32_OFFBIG_CFLAGS */ - {errno = EINVAL; return -1;} -#endif /* ndef _CS_XBS5_ILP32_OFFBIG_CFLAGS */ - if (x == Mono_Posix_ConfStr__CS_XBS5_ILP32_OFFBIG_LDFLAGS) -#ifdef _CS_XBS5_ILP32_OFFBIG_LDFLAGS - {*r = _CS_XBS5_ILP32_OFFBIG_LDFLAGS; return 0;} -#else /* def _CS_XBS5_ILP32_OFFBIG_LDFLAGS */ - {errno = EINVAL; return -1;} -#endif /* ndef _CS_XBS5_ILP32_OFFBIG_LDFLAGS */ - if (x == Mono_Posix_ConfStr__CS_XBS5_ILP32_OFFBIG_LIBS) -#ifdef _CS_XBS5_ILP32_OFFBIG_LIBS - {*r = _CS_XBS5_ILP32_OFFBIG_LIBS; return 0;} -#else /* def _CS_XBS5_ILP32_OFFBIG_LIBS */ - {errno = EINVAL; return -1;} -#endif /* ndef _CS_XBS5_ILP32_OFFBIG_LIBS */ - if (x == Mono_Posix_ConfStr__CS_XBS5_ILP32_OFFBIG_LINTFLAGS) -#ifdef _CS_XBS5_ILP32_OFFBIG_LINTFLAGS - {*r = _CS_XBS5_ILP32_OFFBIG_LINTFLAGS; return 0;} -#else /* def _CS_XBS5_ILP32_OFFBIG_LINTFLAGS */ - {errno = EINVAL; return -1;} -#endif /* ndef _CS_XBS5_ILP32_OFFBIG_LINTFLAGS */ - if (x == Mono_Posix_ConfStr__CS_XBS5_LP64_OFF64_CFLAGS) -#ifdef _CS_XBS5_LP64_OFF64_CFLAGS - {*r = _CS_XBS5_LP64_OFF64_CFLAGS; return 0;} -#else /* def _CS_XBS5_LP64_OFF64_CFLAGS */ - {errno = EINVAL; return -1;} -#endif /* ndef _CS_XBS5_LP64_OFF64_CFLAGS */ - if (x == Mono_Posix_ConfStr__CS_XBS5_LP64_OFF64_LDFLAGS) -#ifdef _CS_XBS5_LP64_OFF64_LDFLAGS - {*r = _CS_XBS5_LP64_OFF64_LDFLAGS; return 0;} -#else /* def _CS_XBS5_LP64_OFF64_LDFLAGS */ - {errno = EINVAL; return -1;} -#endif /* ndef _CS_XBS5_LP64_OFF64_LDFLAGS */ - if (x == Mono_Posix_ConfStr__CS_XBS5_LP64_OFF64_LIBS) -#ifdef _CS_XBS5_LP64_OFF64_LIBS - {*r = _CS_XBS5_LP64_OFF64_LIBS; return 0;} -#else /* def _CS_XBS5_LP64_OFF64_LIBS */ - {errno = EINVAL; return -1;} -#endif /* ndef _CS_XBS5_LP64_OFF64_LIBS */ - if (x == Mono_Posix_ConfStr__CS_XBS5_LP64_OFF64_LINTFLAGS) -#ifdef _CS_XBS5_LP64_OFF64_LINTFLAGS - {*r = _CS_XBS5_LP64_OFF64_LINTFLAGS; return 0;} -#else /* def _CS_XBS5_LP64_OFF64_LINTFLAGS */ - {errno = EINVAL; return -1;} -#endif /* ndef _CS_XBS5_LP64_OFF64_LINTFLAGS */ - if (x == Mono_Posix_ConfStr__CS_XBS5_LPBIG_OFFBIG_CFLAGS) -#ifdef _CS_XBS5_LPBIG_OFFBIG_CFLAGS - {*r = _CS_XBS5_LPBIG_OFFBIG_CFLAGS; return 0;} -#else /* def _CS_XBS5_LPBIG_OFFBIG_CFLAGS */ - {errno = EINVAL; return -1;} -#endif /* ndef _CS_XBS5_LPBIG_OFFBIG_CFLAGS */ - if (x == Mono_Posix_ConfStr__CS_XBS5_LPBIG_OFFBIG_LDFLAGS) -#ifdef _CS_XBS5_LPBIG_OFFBIG_LDFLAGS - {*r = _CS_XBS5_LPBIG_OFFBIG_LDFLAGS; return 0;} -#else /* def _CS_XBS5_LPBIG_OFFBIG_LDFLAGS */ - {errno = EINVAL; return -1;} -#endif /* ndef _CS_XBS5_LPBIG_OFFBIG_LDFLAGS */ - if (x == Mono_Posix_ConfStr__CS_XBS5_LPBIG_OFFBIG_LIBS) -#ifdef _CS_XBS5_LPBIG_OFFBIG_LIBS - {*r = _CS_XBS5_LPBIG_OFFBIG_LIBS; return 0;} -#else /* def _CS_XBS5_LPBIG_OFFBIG_LIBS */ - {errno = EINVAL; return -1;} -#endif /* ndef _CS_XBS5_LPBIG_OFFBIG_LIBS */ - if (x == Mono_Posix_ConfStr__CS_XBS5_LPBIG_OFFBIG_LINTFLAGS) -#ifdef _CS_XBS5_LPBIG_OFFBIG_LINTFLAGS - {*r = _CS_XBS5_LPBIG_OFFBIG_LINTFLAGS; return 0;} -#else /* def _CS_XBS5_LPBIG_OFFBIG_LINTFLAGS */ - {errno = EINVAL; return -1;} -#endif /* ndef _CS_XBS5_LPBIG_OFFBIG_LINTFLAGS */ - errno = EINVAL; return -1; -} +/* returns TRUE if @type is an unsigned type */ +#define _cnm_integral_type_is_unsigned(type) \ + (sizeof(type) == sizeof(gint8) \ + ? (((type)-1) > G_MAXINT8) \ + : sizeof(type) == sizeof(gint16) \ + ? (((type)-1) > G_MAXINT16) \ + : sizeof(type) == sizeof(gint32) \ + ? (((type)-1) > G_MAXINT32) \ + : sizeof(type) == sizeof(gint64) \ + ? (((type)-1) > G_MAXINT64) \ + : (g_assert_not_reached (), 0)) -int Mono_Posix_ToConfStr (int x, int *r) -{ - *r = 0; - if (x == 0) - return 0; -#ifdef _CS_GNU_LIBC_VERSION - if (x == _CS_GNU_LIBC_VERSION) - {*r = Mono_Posix_ConfStr__CS_GNU_LIBC_VERSION; return 0;} -#endif /* ndef _CS_GNU_LIBC_VERSION */ -#ifdef _CS_GNU_LIBPTHREAD_VERSION - if (x == _CS_GNU_LIBPTHREAD_VERSION) - {*r = Mono_Posix_ConfStr__CS_GNU_LIBPTHREAD_VERSION; return 0;} -#endif /* ndef _CS_GNU_LIBPTHREAD_VERSION */ -#ifdef _CS_LFS64_CFLAGS - if (x == _CS_LFS64_CFLAGS) - {*r = Mono_Posix_ConfStr__CS_LFS64_CFLAGS; return 0;} -#endif /* ndef _CS_LFS64_CFLAGS */ -#ifdef _CS_LFS64_LDFLAGS - if (x == _CS_LFS64_LDFLAGS) - {*r = Mono_Posix_ConfStr__CS_LFS64_LDFLAGS; return 0;} -#endif /* ndef _CS_LFS64_LDFLAGS */ -#ifdef _CS_LFS64_LIBS - if (x == _CS_LFS64_LIBS) - {*r = Mono_Posix_ConfStr__CS_LFS64_LIBS; return 0;} -#endif /* ndef _CS_LFS64_LIBS */ -#ifdef _CS_LFS64_LINTFLAGS - if (x == _CS_LFS64_LINTFLAGS) - {*r = Mono_Posix_ConfStr__CS_LFS64_LINTFLAGS; return 0;} -#endif /* ndef _CS_LFS64_LINTFLAGS */ -#ifdef _CS_LFS_CFLAGS - if (x == _CS_LFS_CFLAGS) - {*r = Mono_Posix_ConfStr__CS_LFS_CFLAGS; return 0;} -#endif /* ndef _CS_LFS_CFLAGS */ -#ifdef _CS_LFS_LDFLAGS - if (x == _CS_LFS_LDFLAGS) - {*r = Mono_Posix_ConfStr__CS_LFS_LDFLAGS; return 0;} -#endif /* ndef _CS_LFS_LDFLAGS */ -#ifdef _CS_LFS_LIBS - if (x == _CS_LFS_LIBS) - {*r = Mono_Posix_ConfStr__CS_LFS_LIBS; return 0;} -#endif /* ndef _CS_LFS_LIBS */ -#ifdef _CS_LFS_LINTFLAGS - if (x == _CS_LFS_LINTFLAGS) - {*r = Mono_Posix_ConfStr__CS_LFS_LINTFLAGS; return 0;} -#endif /* ndef _CS_LFS_LINTFLAGS */ -#ifdef _CS_PATH - if (x == _CS_PATH) - {*r = Mono_Posix_ConfStr__CS_PATH; return 0;} -#endif /* ndef _CS_PATH */ -#ifdef _CS_POSIX_V6_ILP32_OFF32_CFLAGS - if (x == _CS_POSIX_V6_ILP32_OFF32_CFLAGS) - {*r = Mono_Posix_ConfStr__CS_POSIX_V6_ILP32_OFF32_CFLAGS; return 0;} -#endif /* ndef _CS_POSIX_V6_ILP32_OFF32_CFLAGS */ -#ifdef _CS_POSIX_V6_ILP32_OFF32_LDFLAGS - if (x == _CS_POSIX_V6_ILP32_OFF32_LDFLAGS) - {*r = Mono_Posix_ConfStr__CS_POSIX_V6_ILP32_OFF32_LDFLAGS; return 0;} -#endif /* ndef _CS_POSIX_V6_ILP32_OFF32_LDFLAGS */ -#ifdef _CS_POSIX_V6_ILP32_OFF32_LIBS - if (x == _CS_POSIX_V6_ILP32_OFF32_LIBS) - {*r = Mono_Posix_ConfStr__CS_POSIX_V6_ILP32_OFF32_LIBS; return 0;} -#endif /* ndef _CS_POSIX_V6_ILP32_OFF32_LIBS */ -#ifdef _CS_POSIX_V6_ILP32_OFF32_LINTFLAGS - if (x == _CS_POSIX_V6_ILP32_OFF32_LINTFLAGS) - {*r = Mono_Posix_ConfStr__CS_POSIX_V6_ILP32_OFF32_LINTFLAGS; return 0;} -#endif /* ndef _CS_POSIX_V6_ILP32_OFF32_LINTFLAGS */ -#ifdef _CS_POSIX_V6_ILP32_OFFBIG_CFLAGS - if (x == _CS_POSIX_V6_ILP32_OFFBIG_CFLAGS) - {*r = Mono_Posix_ConfStr__CS_POSIX_V6_ILP32_OFFBIG_CFLAGS; return 0;} -#endif /* ndef _CS_POSIX_V6_ILP32_OFFBIG_CFLAGS */ -#ifdef _CS_POSIX_V6_ILP32_OFFBIG_LDFLAGS - if (x == _CS_POSIX_V6_ILP32_OFFBIG_LDFLAGS) - {*r = Mono_Posix_ConfStr__CS_POSIX_V6_ILP32_OFFBIG_LDFLAGS; return 0;} -#endif /* ndef _CS_POSIX_V6_ILP32_OFFBIG_LDFLAGS */ -#ifdef _CS_POSIX_V6_ILP32_OFFBIG_LIBS - if (x == _CS_POSIX_V6_ILP32_OFFBIG_LIBS) - {*r = Mono_Posix_ConfStr__CS_POSIX_V6_ILP32_OFFBIG_LIBS; return 0;} -#endif /* ndef _CS_POSIX_V6_ILP32_OFFBIG_LIBS */ -#ifdef _CS_POSIX_V6_ILP32_OFFBIG_LINTFLAGS - if (x == _CS_POSIX_V6_ILP32_OFFBIG_LINTFLAGS) - {*r = Mono_Posix_ConfStr__CS_POSIX_V6_ILP32_OFFBIG_LINTFLAGS; return 0;} -#endif /* ndef _CS_POSIX_V6_ILP32_OFFBIG_LINTFLAGS */ -#ifdef _CS_POSIX_V6_LP64_OFF64_CFLAGS - if (x == _CS_POSIX_V6_LP64_OFF64_CFLAGS) - {*r = Mono_Posix_ConfStr__CS_POSIX_V6_LP64_OFF64_CFLAGS; return 0;} -#endif /* ndef _CS_POSIX_V6_LP64_OFF64_CFLAGS */ -#ifdef _CS_POSIX_V6_LP64_OFF64_LDFLAGS - if (x == _CS_POSIX_V6_LP64_OFF64_LDFLAGS) - {*r = Mono_Posix_ConfStr__CS_POSIX_V6_LP64_OFF64_LDFLAGS; return 0;} -#endif /* ndef _CS_POSIX_V6_LP64_OFF64_LDFLAGS */ -#ifdef _CS_POSIX_V6_LP64_OFF64_LIBS - if (x == _CS_POSIX_V6_LP64_OFF64_LIBS) - {*r = Mono_Posix_ConfStr__CS_POSIX_V6_LP64_OFF64_LIBS; return 0;} -#endif /* ndef _CS_POSIX_V6_LP64_OFF64_LIBS */ -#ifdef _CS_POSIX_V6_LP64_OFF64_LINTFLAGS - if (x == _CS_POSIX_V6_LP64_OFF64_LINTFLAGS) - {*r = Mono_Posix_ConfStr__CS_POSIX_V6_LP64_OFF64_LINTFLAGS; return 0;} -#endif /* ndef _CS_POSIX_V6_LP64_OFF64_LINTFLAGS */ -#ifdef _CS_POSIX_V6_LPBIG_OFFBIG_CFLAGS - if (x == _CS_POSIX_V6_LPBIG_OFFBIG_CFLAGS) - {*r = Mono_Posix_ConfStr__CS_POSIX_V6_LPBIG_OFFBIG_CFLAGS; return 0;} -#endif /* ndef _CS_POSIX_V6_LPBIG_OFFBIG_CFLAGS */ -#ifdef _CS_POSIX_V6_LPBIG_OFFBIG_LDFLAGS - if (x == _CS_POSIX_V6_LPBIG_OFFBIG_LDFLAGS) - {*r = Mono_Posix_ConfStr__CS_POSIX_V6_LPBIG_OFFBIG_LDFLAGS; return 0;} -#endif /* ndef _CS_POSIX_V6_LPBIG_OFFBIG_LDFLAGS */ -#ifdef _CS_POSIX_V6_LPBIG_OFFBIG_LIBS - if (x == _CS_POSIX_V6_LPBIG_OFFBIG_LIBS) - {*r = Mono_Posix_ConfStr__CS_POSIX_V6_LPBIG_OFFBIG_LIBS; return 0;} -#endif /* ndef _CS_POSIX_V6_LPBIG_OFFBIG_LIBS */ -#ifdef _CS_POSIX_V6_LPBIG_OFFBIG_LINTFLAGS - if (x == _CS_POSIX_V6_LPBIG_OFFBIG_LINTFLAGS) - {*r = Mono_Posix_ConfStr__CS_POSIX_V6_LPBIG_OFFBIG_LINTFLAGS; return 0;} -#endif /* ndef _CS_POSIX_V6_LPBIG_OFFBIG_LINTFLAGS */ -#ifdef _CS_V6_WIDTH_RESTRICTED_ENVS - if (x == _CS_V6_WIDTH_RESTRICTED_ENVS) - {*r = Mono_Posix_ConfStr__CS_V6_WIDTH_RESTRICTED_ENVS; return 0;} -#endif /* ndef _CS_V6_WIDTH_RESTRICTED_ENVS */ -#ifdef _CS_XBS5_ILP32_OFF32_CFLAGS - if (x == _CS_XBS5_ILP32_OFF32_CFLAGS) - {*r = Mono_Posix_ConfStr__CS_XBS5_ILP32_OFF32_CFLAGS; return 0;} -#endif /* ndef _CS_XBS5_ILP32_OFF32_CFLAGS */ -#ifdef _CS_XBS5_ILP32_OFF32_LDFLAGS - if (x == _CS_XBS5_ILP32_OFF32_LDFLAGS) - {*r = Mono_Posix_ConfStr__CS_XBS5_ILP32_OFF32_LDFLAGS; return 0;} -#endif /* ndef _CS_XBS5_ILP32_OFF32_LDFLAGS */ -#ifdef _CS_XBS5_ILP32_OFF32_LIBS - if (x == _CS_XBS5_ILP32_OFF32_LIBS) - {*r = Mono_Posix_ConfStr__CS_XBS5_ILP32_OFF32_LIBS; return 0;} -#endif /* ndef _CS_XBS5_ILP32_OFF32_LIBS */ -#ifdef _CS_XBS5_ILP32_OFF32_LINTFLAGS - if (x == _CS_XBS5_ILP32_OFF32_LINTFLAGS) - {*r = Mono_Posix_ConfStr__CS_XBS5_ILP32_OFF32_LINTFLAGS; return 0;} -#endif /* ndef _CS_XBS5_ILP32_OFF32_LINTFLAGS */ -#ifdef _CS_XBS5_ILP32_OFFBIG_CFLAGS - if (x == _CS_XBS5_ILP32_OFFBIG_CFLAGS) - {*r = Mono_Posix_ConfStr__CS_XBS5_ILP32_OFFBIG_CFLAGS; return 0;} -#endif /* ndef _CS_XBS5_ILP32_OFFBIG_CFLAGS */ -#ifdef _CS_XBS5_ILP32_OFFBIG_LDFLAGS - if (x == _CS_XBS5_ILP32_OFFBIG_LDFLAGS) - {*r = Mono_Posix_ConfStr__CS_XBS5_ILP32_OFFBIG_LDFLAGS; return 0;} -#endif /* ndef _CS_XBS5_ILP32_OFFBIG_LDFLAGS */ -#ifdef _CS_XBS5_ILP32_OFFBIG_LIBS - if (x == _CS_XBS5_ILP32_OFFBIG_LIBS) - {*r = Mono_Posix_ConfStr__CS_XBS5_ILP32_OFFBIG_LIBS; return 0;} -#endif /* ndef _CS_XBS5_ILP32_OFFBIG_LIBS */ -#ifdef _CS_XBS5_ILP32_OFFBIG_LINTFLAGS - if (x == _CS_XBS5_ILP32_OFFBIG_LINTFLAGS) - {*r = Mono_Posix_ConfStr__CS_XBS5_ILP32_OFFBIG_LINTFLAGS; return 0;} -#endif /* ndef _CS_XBS5_ILP32_OFFBIG_LINTFLAGS */ -#ifdef _CS_XBS5_LP64_OFF64_CFLAGS - if (x == _CS_XBS5_LP64_OFF64_CFLAGS) - {*r = Mono_Posix_ConfStr__CS_XBS5_LP64_OFF64_CFLAGS; return 0;} -#endif /* ndef _CS_XBS5_LP64_OFF64_CFLAGS */ -#ifdef _CS_XBS5_LP64_OFF64_LDFLAGS - if (x == _CS_XBS5_LP64_OFF64_LDFLAGS) - {*r = Mono_Posix_ConfStr__CS_XBS5_LP64_OFF64_LDFLAGS; return 0;} -#endif /* ndef _CS_XBS5_LP64_OFF64_LDFLAGS */ -#ifdef _CS_XBS5_LP64_OFF64_LIBS - if (x == _CS_XBS5_LP64_OFF64_LIBS) - {*r = Mono_Posix_ConfStr__CS_XBS5_LP64_OFF64_LIBS; return 0;} -#endif /* ndef _CS_XBS5_LP64_OFF64_LIBS */ -#ifdef _CS_XBS5_LP64_OFF64_LINTFLAGS - if (x == _CS_XBS5_LP64_OFF64_LINTFLAGS) - {*r = Mono_Posix_ConfStr__CS_XBS5_LP64_OFF64_LINTFLAGS; return 0;} -#endif /* ndef _CS_XBS5_LP64_OFF64_LINTFLAGS */ -#ifdef _CS_XBS5_LPBIG_OFFBIG_CFLAGS - if (x == _CS_XBS5_LPBIG_OFFBIG_CFLAGS) - {*r = Mono_Posix_ConfStr__CS_XBS5_LPBIG_OFFBIG_CFLAGS; return 0;} -#endif /* ndef _CS_XBS5_LPBIG_OFFBIG_CFLAGS */ -#ifdef _CS_XBS5_LPBIG_OFFBIG_LDFLAGS - if (x == _CS_XBS5_LPBIG_OFFBIG_LDFLAGS) - {*r = Mono_Posix_ConfStr__CS_XBS5_LPBIG_OFFBIG_LDFLAGS; return 0;} -#endif /* ndef _CS_XBS5_LPBIG_OFFBIG_LDFLAGS */ -#ifdef _CS_XBS5_LPBIG_OFFBIG_LIBS - if (x == _CS_XBS5_LPBIG_OFFBIG_LIBS) - {*r = Mono_Posix_ConfStr__CS_XBS5_LPBIG_OFFBIG_LIBS; return 0;} -#endif /* ndef _CS_XBS5_LPBIG_OFFBIG_LIBS */ -#ifdef _CS_XBS5_LPBIG_OFFBIG_LINTFLAGS - if (x == _CS_XBS5_LPBIG_OFFBIG_LINTFLAGS) - {*r = Mono_Posix_ConfStr__CS_XBS5_LPBIG_OFFBIG_LINTFLAGS; return 0;} -#endif /* ndef _CS_XBS5_LPBIG_OFFBIG_LINTFLAGS */ - errno = EINVAL; return -1; -} +/* returns the minimum value of @type as a gint64 */ +#define _cnm_integral_type_min(type) \ + (_cnm_integral_type_is_unsigned (type) \ + ? 0 \ + : sizeof(type) == sizeof(gint8) \ + ? G_MININT8 \ + : sizeof(type) == sizeof(gint16) \ + ? G_MININT16 \ + : sizeof(type) == sizeof(gint32) \ + ? G_MININT32 \ + : sizeof(type) == sizeof(gint64) \ + ? G_MININT64 \ + : (g_assert_not_reached (), 0)) -int Mono_Posix_FromError (int x, int *r) -{ - *r = 0; - if (x == 0) - return 0; - if (x == Mono_Posix_Error_E2BIG) -#ifdef E2BIG - {*r = E2BIG; return 0;} -#else /* def E2BIG */ - {errno = EINVAL; return -1;} -#endif /* ndef E2BIG */ - if (x == Mono_Posix_Error_EACCES) -#ifdef EACCES - {*r = EACCES; return 0;} -#else /* def EACCES */ - {errno = EINVAL; return -1;} -#endif /* ndef EACCES */ - if (x == Mono_Posix_Error_EADDRINUSE) -#ifdef EADDRINUSE - {*r = EADDRINUSE; return 0;} -#else /* def EADDRINUSE */ - {errno = EINVAL; return -1;} -#endif /* ndef EADDRINUSE */ - if (x == Mono_Posix_Error_EADDRNOTAVAIL) -#ifdef EADDRNOTAVAIL - {*r = EADDRNOTAVAIL; return 0;} -#else /* def EADDRNOTAVAIL */ - {errno = EINVAL; return -1;} -#endif /* ndef EADDRNOTAVAIL */ - if (x == Mono_Posix_Error_EADV) -#ifdef EADV - {*r = EADV; return 0;} -#else /* def EADV */ - {errno = EINVAL; return -1;} -#endif /* ndef EADV */ - if (x == Mono_Posix_Error_EAFNOSUPPORT) -#ifdef EAFNOSUPPORT - {*r = EAFNOSUPPORT; return 0;} -#else /* def EAFNOSUPPORT */ - {errno = EINVAL; return -1;} -#endif /* ndef EAFNOSUPPORT */ - if (x == Mono_Posix_Error_EAGAIN) -#ifdef EAGAIN - {*r = EAGAIN; return 0;} -#else /* def EAGAIN */ - {errno = EINVAL; return -1;} -#endif /* ndef EAGAIN */ - if (x == Mono_Posix_Error_EALREADY) -#ifdef EALREADY - {*r = EALREADY; return 0;} -#else /* def EALREADY */ - {errno = EINVAL; return -1;} -#endif /* ndef EALREADY */ - if (x == Mono_Posix_Error_EBADE) -#ifdef EBADE - {*r = EBADE; return 0;} -#else /* def EBADE */ - {errno = EINVAL; return -1;} -#endif /* ndef EBADE */ - if (x == Mono_Posix_Error_EBADF) -#ifdef EBADF - {*r = EBADF; return 0;} -#else /* def EBADF */ - {errno = EINVAL; return -1;} -#endif /* ndef EBADF */ - if (x == Mono_Posix_Error_EBADFD) -#ifdef EBADFD - {*r = EBADFD; return 0;} -#else /* def EBADFD */ - {errno = EINVAL; return -1;} -#endif /* ndef EBADFD */ - if (x == Mono_Posix_Error_EBADMSG) -#ifdef EBADMSG - {*r = EBADMSG; return 0;} -#else /* def EBADMSG */ - {errno = EINVAL; return -1;} -#endif /* ndef EBADMSG */ - if (x == Mono_Posix_Error_EBADR) -#ifdef EBADR - {*r = EBADR; return 0;} -#else /* def EBADR */ - {errno = EINVAL; return -1;} -#endif /* ndef EBADR */ - if (x == Mono_Posix_Error_EBADRQC) -#ifdef EBADRQC - {*r = EBADRQC; return 0;} -#else /* def EBADRQC */ - {errno = EINVAL; return -1;} -#endif /* ndef EBADRQC */ - if (x == Mono_Posix_Error_EBADSLT) -#ifdef EBADSLT - {*r = EBADSLT; return 0;} -#else /* def EBADSLT */ - {errno = EINVAL; return -1;} -#endif /* ndef EBADSLT */ - if (x == Mono_Posix_Error_EBFONT) -#ifdef EBFONT - {*r = EBFONT; return 0;} -#else /* def EBFONT */ - {errno = EINVAL; return -1;} -#endif /* ndef EBFONT */ - if (x == Mono_Posix_Error_EBUSY) -#ifdef EBUSY - {*r = EBUSY; return 0;} -#else /* def EBUSY */ - {errno = EINVAL; return -1;} -#endif /* ndef EBUSY */ - if (x == Mono_Posix_Error_ECHILD) -#ifdef ECHILD - {*r = ECHILD; return 0;} -#else /* def ECHILD */ - {errno = EINVAL; return -1;} -#endif /* ndef ECHILD */ - if (x == Mono_Posix_Error_ECHRNG) -#ifdef ECHRNG - {*r = ECHRNG; return 0;} -#else /* def ECHRNG */ - {errno = EINVAL; return -1;} -#endif /* ndef ECHRNG */ - if (x == Mono_Posix_Error_ECOMM) -#ifdef ECOMM - {*r = ECOMM; return 0;} -#else /* def ECOMM */ - {errno = EINVAL; return -1;} -#endif /* ndef ECOMM */ - if (x == Mono_Posix_Error_ECONNABORTED) -#ifdef ECONNABORTED - {*r = ECONNABORTED; return 0;} -#else /* def ECONNABORTED */ - {errno = EINVAL; return -1;} -#endif /* ndef ECONNABORTED */ - if (x == Mono_Posix_Error_ECONNREFUSED) -#ifdef ECONNREFUSED - {*r = ECONNREFUSED; return 0;} -#else /* def ECONNREFUSED */ - {errno = EINVAL; return -1;} -#endif /* ndef ECONNREFUSED */ - if (x == Mono_Posix_Error_ECONNRESET) -#ifdef ECONNRESET - {*r = ECONNRESET; return 0;} -#else /* def ECONNRESET */ - {errno = EINVAL; return -1;} -#endif /* ndef ECONNRESET */ - if (x == Mono_Posix_Error_EDEADLK) -#ifdef EDEADLK - {*r = EDEADLK; return 0;} -#else /* def EDEADLK */ - {errno = EINVAL; return -1;} -#endif /* ndef EDEADLK */ - if (x == Mono_Posix_Error_EDEADLOCK) -#ifdef EDEADLOCK - {*r = EDEADLOCK; return 0;} -#else /* def EDEADLOCK */ - {errno = EINVAL; return -1;} -#endif /* ndef EDEADLOCK */ - if (x == Mono_Posix_Error_EDESTADDRREQ) -#ifdef EDESTADDRREQ - {*r = EDESTADDRREQ; return 0;} -#else /* def EDESTADDRREQ */ - {errno = EINVAL; return -1;} -#endif /* ndef EDESTADDRREQ */ - if (x == Mono_Posix_Error_EDOM) -#ifdef EDOM - {*r = EDOM; return 0;} -#else /* def EDOM */ - {errno = EINVAL; return -1;} -#endif /* ndef EDOM */ - if (x == Mono_Posix_Error_EDOTDOT) -#ifdef EDOTDOT - {*r = EDOTDOT; return 0;} -#else /* def EDOTDOT */ - {errno = EINVAL; return -1;} -#endif /* ndef EDOTDOT */ - if (x == Mono_Posix_Error_EDQUOT) -#ifdef EDQUOT - {*r = EDQUOT; return 0;} -#else /* def EDQUOT */ - {errno = EINVAL; return -1;} -#endif /* ndef EDQUOT */ - if (x == Mono_Posix_Error_EEXIST) -#ifdef EEXIST - {*r = EEXIST; return 0;} -#else /* def EEXIST */ - {errno = EINVAL; return -1;} -#endif /* ndef EEXIST */ - if (x == Mono_Posix_Error_EFAULT) -#ifdef EFAULT - {*r = EFAULT; return 0;} -#else /* def EFAULT */ - {errno = EINVAL; return -1;} -#endif /* ndef EFAULT */ - if (x == Mono_Posix_Error_EFBIG) -#ifdef EFBIG - {*r = EFBIG; return 0;} -#else /* def EFBIG */ - {errno = EINVAL; return -1;} -#endif /* ndef EFBIG */ - if (x == Mono_Posix_Error_EHOSTDOWN) -#ifdef EHOSTDOWN - {*r = EHOSTDOWN; return 0;} -#else /* def EHOSTDOWN */ - {errno = EINVAL; return -1;} -#endif /* ndef EHOSTDOWN */ - if (x == Mono_Posix_Error_EHOSTUNREACH) -#ifdef EHOSTUNREACH - {*r = EHOSTUNREACH; return 0;} -#else /* def EHOSTUNREACH */ - {errno = EINVAL; return -1;} -#endif /* ndef EHOSTUNREACH */ - if (x == Mono_Posix_Error_EIDRM) -#ifdef EIDRM - {*r = EIDRM; return 0;} -#else /* def EIDRM */ - {errno = EINVAL; return -1;} -#endif /* ndef EIDRM */ - if (x == Mono_Posix_Error_EILSEQ) -#ifdef EILSEQ - {*r = EILSEQ; return 0;} -#else /* def EILSEQ */ - {errno = EINVAL; return -1;} -#endif /* ndef EILSEQ */ - if (x == Mono_Posix_Error_EINPROGRESS) -#ifdef EINPROGRESS - {*r = EINPROGRESS; return 0;} -#else /* def EINPROGRESS */ - {errno = EINVAL; return -1;} -#endif /* ndef EINPROGRESS */ - if (x == Mono_Posix_Error_EINTR) -#ifdef EINTR - {*r = EINTR; return 0;} -#else /* def EINTR */ - {errno = EINVAL; return -1;} -#endif /* ndef EINTR */ - if (x == Mono_Posix_Error_EINVAL) -#ifdef EINVAL - {*r = EINVAL; return 0;} -#else /* def EINVAL */ - {errno = EINVAL; return -1;} -#endif /* ndef EINVAL */ - if (x == Mono_Posix_Error_EIO) -#ifdef EIO - {*r = EIO; return 0;} -#else /* def EIO */ - {errno = EINVAL; return -1;} -#endif /* ndef EIO */ - if (x == Mono_Posix_Error_EISCONN) -#ifdef EISCONN - {*r = EISCONN; return 0;} -#else /* def EISCONN */ - {errno = EINVAL; return -1;} -#endif /* ndef EISCONN */ - if (x == Mono_Posix_Error_EISDIR) -#ifdef EISDIR - {*r = EISDIR; return 0;} -#else /* def EISDIR */ - {errno = EINVAL; return -1;} -#endif /* ndef EISDIR */ - if (x == Mono_Posix_Error_EISNAM) -#ifdef EISNAM - {*r = EISNAM; return 0;} -#else /* def EISNAM */ - {errno = EINVAL; return -1;} -#endif /* ndef EISNAM */ - if (x == Mono_Posix_Error_EL2HLT) -#ifdef EL2HLT - {*r = EL2HLT; return 0;} -#else /* def EL2HLT */ - {errno = EINVAL; return -1;} -#endif /* ndef EL2HLT */ - if (x == Mono_Posix_Error_EL2NSYNC) -#ifdef EL2NSYNC - {*r = EL2NSYNC; return 0;} -#else /* def EL2NSYNC */ - {errno = EINVAL; return -1;} -#endif /* ndef EL2NSYNC */ - if (x == Mono_Posix_Error_EL3HLT) -#ifdef EL3HLT - {*r = EL3HLT; return 0;} -#else /* def EL3HLT */ - {errno = EINVAL; return -1;} -#endif /* ndef EL3HLT */ - if (x == Mono_Posix_Error_EL3RST) -#ifdef EL3RST - {*r = EL3RST; return 0;} -#else /* def EL3RST */ - {errno = EINVAL; return -1;} -#endif /* ndef EL3RST */ - if (x == Mono_Posix_Error_ELIBACC) -#ifdef ELIBACC - {*r = ELIBACC; return 0;} -#else /* def ELIBACC */ - {errno = EINVAL; return -1;} -#endif /* ndef ELIBACC */ - if (x == Mono_Posix_Error_ELIBBAD) -#ifdef ELIBBAD - {*r = ELIBBAD; return 0;} -#else /* def ELIBBAD */ - {errno = EINVAL; return -1;} -#endif /* ndef ELIBBAD */ - if (x == Mono_Posix_Error_ELIBEXEC) -#ifdef ELIBEXEC - {*r = ELIBEXEC; return 0;} -#else /* def ELIBEXEC */ - {errno = EINVAL; return -1;} -#endif /* ndef ELIBEXEC */ - if (x == Mono_Posix_Error_ELIBMAX) -#ifdef ELIBMAX - {*r = ELIBMAX; return 0;} -#else /* def ELIBMAX */ - {errno = EINVAL; return -1;} -#endif /* ndef ELIBMAX */ - if (x == Mono_Posix_Error_ELIBSCN) -#ifdef ELIBSCN - {*r = ELIBSCN; return 0;} -#else /* def ELIBSCN */ - {errno = EINVAL; return -1;} -#endif /* ndef ELIBSCN */ - if (x == Mono_Posix_Error_ELNRNG) -#ifdef ELNRNG - {*r = ELNRNG; return 0;} -#else /* def ELNRNG */ - {errno = EINVAL; return -1;} -#endif /* ndef ELNRNG */ - if (x == Mono_Posix_Error_ELOOP) -#ifdef ELOOP - {*r = ELOOP; return 0;} -#else /* def ELOOP */ - {errno = EINVAL; return -1;} -#endif /* ndef ELOOP */ - if (x == Mono_Posix_Error_EMEDIUMTYPE) -#ifdef EMEDIUMTYPE - {*r = EMEDIUMTYPE; return 0;} -#else /* def EMEDIUMTYPE */ - {errno = EINVAL; return -1;} -#endif /* ndef EMEDIUMTYPE */ - if (x == Mono_Posix_Error_EMFILE) -#ifdef EMFILE - {*r = EMFILE; return 0;} -#else /* def EMFILE */ - {errno = EINVAL; return -1;} -#endif /* ndef EMFILE */ - if (x == Mono_Posix_Error_EMLINK) -#ifdef EMLINK - {*r = EMLINK; return 0;} -#else /* def EMLINK */ - {errno = EINVAL; return -1;} -#endif /* ndef EMLINK */ - if (x == Mono_Posix_Error_EMSGSIZE) -#ifdef EMSGSIZE - {*r = EMSGSIZE; return 0;} -#else /* def EMSGSIZE */ - {errno = EINVAL; return -1;} -#endif /* ndef EMSGSIZE */ - if (x == Mono_Posix_Error_EMULTIHOP) -#ifdef EMULTIHOP - {*r = EMULTIHOP; return 0;} -#else /* def EMULTIHOP */ - {errno = EINVAL; return -1;} -#endif /* ndef EMULTIHOP */ - if (x == Mono_Posix_Error_ENAMETOOLONG) -#ifdef ENAMETOOLONG - {*r = ENAMETOOLONG; return 0;} -#else /* def ENAMETOOLONG */ - {errno = EINVAL; return -1;} -#endif /* ndef ENAMETOOLONG */ - if (x == Mono_Posix_Error_ENAVAIL) -#ifdef ENAVAIL - {*r = ENAVAIL; return 0;} -#else /* def ENAVAIL */ - {errno = EINVAL; return -1;} -#endif /* ndef ENAVAIL */ - if (x == Mono_Posix_Error_ENETDOWN) -#ifdef ENETDOWN - {*r = ENETDOWN; return 0;} -#else /* def ENETDOWN */ - {errno = EINVAL; return -1;} -#endif /* ndef ENETDOWN */ - if (x == Mono_Posix_Error_ENETRESET) -#ifdef ENETRESET - {*r = ENETRESET; return 0;} -#else /* def ENETRESET */ - {errno = EINVAL; return -1;} -#endif /* ndef ENETRESET */ - if (x == Mono_Posix_Error_ENETUNREACH) -#ifdef ENETUNREACH - {*r = ENETUNREACH; return 0;} -#else /* def ENETUNREACH */ - {errno = EINVAL; return -1;} -#endif /* ndef ENETUNREACH */ - if (x == Mono_Posix_Error_ENFILE) -#ifdef ENFILE - {*r = ENFILE; return 0;} -#else /* def ENFILE */ - {errno = EINVAL; return -1;} -#endif /* ndef ENFILE */ - if (x == Mono_Posix_Error_ENOANO) -#ifdef ENOANO - {*r = ENOANO; return 0;} -#else /* def ENOANO */ - {errno = EINVAL; return -1;} -#endif /* ndef ENOANO */ - if (x == Mono_Posix_Error_ENOBUFS) -#ifdef ENOBUFS - {*r = ENOBUFS; return 0;} -#else /* def ENOBUFS */ - {errno = EINVAL; return -1;} -#endif /* ndef ENOBUFS */ - if (x == Mono_Posix_Error_ENOCSI) -#ifdef ENOCSI - {*r = ENOCSI; return 0;} -#else /* def ENOCSI */ - {errno = EINVAL; return -1;} -#endif /* ndef ENOCSI */ - if (x == Mono_Posix_Error_ENODATA) -#ifdef ENODATA - {*r = ENODATA; return 0;} -#else /* def ENODATA */ - {errno = EINVAL; return -1;} -#endif /* ndef ENODATA */ - if (x == Mono_Posix_Error_ENODEV) -#ifdef ENODEV - {*r = ENODEV; return 0;} -#else /* def ENODEV */ - {errno = EINVAL; return -1;} -#endif /* ndef ENODEV */ - if (x == Mono_Posix_Error_ENOENT) -#ifdef ENOENT - {*r = ENOENT; return 0;} -#else /* def ENOENT */ - {errno = EINVAL; return -1;} -#endif /* ndef ENOENT */ - if (x == Mono_Posix_Error_ENOEXEC) -#ifdef ENOEXEC - {*r = ENOEXEC; return 0;} -#else /* def ENOEXEC */ - {errno = EINVAL; return -1;} -#endif /* ndef ENOEXEC */ - if (x == Mono_Posix_Error_ENOLCK) -#ifdef ENOLCK - {*r = ENOLCK; return 0;} -#else /* def ENOLCK */ - {errno = EINVAL; return -1;} -#endif /* ndef ENOLCK */ - if (x == Mono_Posix_Error_ENOLINK) -#ifdef ENOLINK - {*r = ENOLINK; return 0;} -#else /* def ENOLINK */ - {errno = EINVAL; return -1;} -#endif /* ndef ENOLINK */ - if (x == Mono_Posix_Error_ENOMEDIUM) -#ifdef ENOMEDIUM - {*r = ENOMEDIUM; return 0;} -#else /* def ENOMEDIUM */ - {errno = EINVAL; return -1;} -#endif /* ndef ENOMEDIUM */ - if (x == Mono_Posix_Error_ENOMEM) -#ifdef ENOMEM - {*r = ENOMEM; return 0;} -#else /* def ENOMEM */ - {errno = EINVAL; return -1;} -#endif /* ndef ENOMEM */ - if (x == Mono_Posix_Error_ENOMSG) -#ifdef ENOMSG - {*r = ENOMSG; return 0;} -#else /* def ENOMSG */ - {errno = EINVAL; return -1;} -#endif /* ndef ENOMSG */ - if (x == Mono_Posix_Error_ENONET) -#ifdef ENONET - {*r = ENONET; return 0;} -#else /* def ENONET */ - {errno = EINVAL; return -1;} -#endif /* ndef ENONET */ - if (x == Mono_Posix_Error_ENOPKG) -#ifdef ENOPKG - {*r = ENOPKG; return 0;} -#else /* def ENOPKG */ - {errno = EINVAL; return -1;} -#endif /* ndef ENOPKG */ - if (x == Mono_Posix_Error_ENOPROTOOPT) -#ifdef ENOPROTOOPT - {*r = ENOPROTOOPT; return 0;} -#else /* def ENOPROTOOPT */ - {errno = EINVAL; return -1;} -#endif /* ndef ENOPROTOOPT */ - if (x == Mono_Posix_Error_ENOSPC) -#ifdef ENOSPC - {*r = ENOSPC; return 0;} -#else /* def ENOSPC */ - {errno = EINVAL; return -1;} -#endif /* ndef ENOSPC */ - if (x == Mono_Posix_Error_ENOSR) -#ifdef ENOSR - {*r = ENOSR; return 0;} -#else /* def ENOSR */ - {errno = EINVAL; return -1;} -#endif /* ndef ENOSR */ - if (x == Mono_Posix_Error_ENOSTR) -#ifdef ENOSTR - {*r = ENOSTR; return 0;} -#else /* def ENOSTR */ - {errno = EINVAL; return -1;} -#endif /* ndef ENOSTR */ - if (x == Mono_Posix_Error_ENOSYS) -#ifdef ENOSYS - {*r = ENOSYS; return 0;} -#else /* def ENOSYS */ - {errno = EINVAL; return -1;} -#endif /* ndef ENOSYS */ - if (x == Mono_Posix_Error_ENOTBLK) -#ifdef ENOTBLK - {*r = ENOTBLK; return 0;} -#else /* def ENOTBLK */ - {errno = EINVAL; return -1;} -#endif /* ndef ENOTBLK */ - if (x == Mono_Posix_Error_ENOTCONN) -#ifdef ENOTCONN - {*r = ENOTCONN; return 0;} -#else /* def ENOTCONN */ - {errno = EINVAL; return -1;} -#endif /* ndef ENOTCONN */ - if (x == Mono_Posix_Error_ENOTDIR) -#ifdef ENOTDIR - {*r = ENOTDIR; return 0;} -#else /* def ENOTDIR */ - {errno = EINVAL; return -1;} -#endif /* ndef ENOTDIR */ - if (x == Mono_Posix_Error_ENOTEMPTY) -#ifdef ENOTEMPTY - {*r = ENOTEMPTY; return 0;} -#else /* def ENOTEMPTY */ - {errno = EINVAL; return -1;} -#endif /* ndef ENOTEMPTY */ - if (x == Mono_Posix_Error_ENOTNAM) -#ifdef ENOTNAM - {*r = ENOTNAM; return 0;} -#else /* def ENOTNAM */ - {errno = EINVAL; return -1;} -#endif /* ndef ENOTNAM */ - if (x == Mono_Posix_Error_ENOTSOCK) -#ifdef ENOTSOCK - {*r = ENOTSOCK; return 0;} -#else /* def ENOTSOCK */ - {errno = EINVAL; return -1;} -#endif /* ndef ENOTSOCK */ - if (x == Mono_Posix_Error_ENOTTY) -#ifdef ENOTTY - {*r = ENOTTY; return 0;} -#else /* def ENOTTY */ - {errno = EINVAL; return -1;} -#endif /* ndef ENOTTY */ - if (x == Mono_Posix_Error_ENOTUNIQ) -#ifdef ENOTUNIQ - {*r = ENOTUNIQ; return 0;} -#else /* def ENOTUNIQ */ - {errno = EINVAL; return -1;} -#endif /* ndef ENOTUNIQ */ - if (x == Mono_Posix_Error_ENXIO) -#ifdef ENXIO - {*r = ENXIO; return 0;} -#else /* def ENXIO */ - {errno = EINVAL; return -1;} -#endif /* ndef ENXIO */ - if (x == Mono_Posix_Error_EOPNOTSUPP) -#ifdef EOPNOTSUPP - {*r = EOPNOTSUPP; return 0;} -#else /* def EOPNOTSUPP */ - {errno = EINVAL; return -1;} -#endif /* ndef EOPNOTSUPP */ - if (x == Mono_Posix_Error_EOVERFLOW) -#ifdef EOVERFLOW - {*r = EOVERFLOW; return 0;} -#else /* def EOVERFLOW */ - {errno = EINVAL; return -1;} -#endif /* ndef EOVERFLOW */ - if (x == Mono_Posix_Error_EPERM) -#ifdef EPERM - {*r = EPERM; return 0;} -#else /* def EPERM */ - {errno = EINVAL; return -1;} -#endif /* ndef EPERM */ - if (x == Mono_Posix_Error_EPFNOSUPPORT) -#ifdef EPFNOSUPPORT - {*r = EPFNOSUPPORT; return 0;} -#else /* def EPFNOSUPPORT */ - {errno = EINVAL; return -1;} -#endif /* ndef EPFNOSUPPORT */ - if (x == Mono_Posix_Error_EPIPE) -#ifdef EPIPE - {*r = EPIPE; return 0;} -#else /* def EPIPE */ - {errno = EINVAL; return -1;} -#endif /* ndef EPIPE */ - if (x == Mono_Posix_Error_EPROTO) -#ifdef EPROTO - {*r = EPROTO; return 0;} -#else /* def EPROTO */ - {errno = EINVAL; return -1;} -#endif /* ndef EPROTO */ - if (x == Mono_Posix_Error_EPROTONOSUPPORT) -#ifdef EPROTONOSUPPORT - {*r = EPROTONOSUPPORT; return 0;} -#else /* def EPROTONOSUPPORT */ - {errno = EINVAL; return -1;} -#endif /* ndef EPROTONOSUPPORT */ - if (x == Mono_Posix_Error_EPROTOTYPE) -#ifdef EPROTOTYPE - {*r = EPROTOTYPE; return 0;} -#else /* def EPROTOTYPE */ - {errno = EINVAL; return -1;} -#endif /* ndef EPROTOTYPE */ - if (x == Mono_Posix_Error_ERANGE) -#ifdef ERANGE - {*r = ERANGE; return 0;} -#else /* def ERANGE */ - {errno = EINVAL; return -1;} -#endif /* ndef ERANGE */ - if (x == Mono_Posix_Error_EREMCHG) -#ifdef EREMCHG - {*r = EREMCHG; return 0;} -#else /* def EREMCHG */ - {errno = EINVAL; return -1;} -#endif /* ndef EREMCHG */ - if (x == Mono_Posix_Error_EREMOTE) -#ifdef EREMOTE - {*r = EREMOTE; return 0;} -#else /* def EREMOTE */ - {errno = EINVAL; return -1;} -#endif /* ndef EREMOTE */ - if (x == Mono_Posix_Error_EREMOTEIO) -#ifdef EREMOTEIO - {*r = EREMOTEIO; return 0;} -#else /* def EREMOTEIO */ - {errno = EINVAL; return -1;} -#endif /* ndef EREMOTEIO */ - if (x == Mono_Posix_Error_ERESTART) -#ifdef ERESTART - {*r = ERESTART; return 0;} -#else /* def ERESTART */ - {errno = EINVAL; return -1;} -#endif /* ndef ERESTART */ - if (x == Mono_Posix_Error_EROFS) -#ifdef EROFS - {*r = EROFS; return 0;} -#else /* def EROFS */ - {errno = EINVAL; return -1;} -#endif /* ndef EROFS */ - if (x == Mono_Posix_Error_ESHUTDOWN) -#ifdef ESHUTDOWN - {*r = ESHUTDOWN; return 0;} -#else /* def ESHUTDOWN */ - {errno = EINVAL; return -1;} -#endif /* ndef ESHUTDOWN */ - if (x == Mono_Posix_Error_ESOCKTNOSUPPORT) -#ifdef ESOCKTNOSUPPORT - {*r = ESOCKTNOSUPPORT; return 0;} -#else /* def ESOCKTNOSUPPORT */ - {errno = EINVAL; return -1;} -#endif /* ndef ESOCKTNOSUPPORT */ - if (x == Mono_Posix_Error_ESPIPE) -#ifdef ESPIPE - {*r = ESPIPE; return 0;} -#else /* def ESPIPE */ - {errno = EINVAL; return -1;} -#endif /* ndef ESPIPE */ - if (x == Mono_Posix_Error_ESRCH) -#ifdef ESRCH - {*r = ESRCH; return 0;} -#else /* def ESRCH */ - {errno = EINVAL; return -1;} -#endif /* ndef ESRCH */ - if (x == Mono_Posix_Error_ESRMNT) -#ifdef ESRMNT - {*r = ESRMNT; return 0;} -#else /* def ESRMNT */ - {errno = EINVAL; return -1;} -#endif /* ndef ESRMNT */ - if (x == Mono_Posix_Error_ESTALE) -#ifdef ESTALE - {*r = ESTALE; return 0;} -#else /* def ESTALE */ - {errno = EINVAL; return -1;} -#endif /* ndef ESTALE */ - if (x == Mono_Posix_Error_ESTRPIPE) -#ifdef ESTRPIPE - {*r = ESTRPIPE; return 0;} -#else /* def ESTRPIPE */ - {errno = EINVAL; return -1;} -#endif /* ndef ESTRPIPE */ - if (x == Mono_Posix_Error_ETIME) -#ifdef ETIME - {*r = ETIME; return 0;} -#else /* def ETIME */ - {errno = EINVAL; return -1;} -#endif /* ndef ETIME */ - if (x == Mono_Posix_Error_ETIMEDOUT) -#ifdef ETIMEDOUT - {*r = ETIMEDOUT; return 0;} -#else /* def ETIMEDOUT */ - {errno = EINVAL; return -1;} -#endif /* ndef ETIMEDOUT */ - if (x == Mono_Posix_Error_ETOOMANYREFS) -#ifdef ETOOMANYREFS - {*r = ETOOMANYREFS; return 0;} -#else /* def ETOOMANYREFS */ - {errno = EINVAL; return -1;} -#endif /* ndef ETOOMANYREFS */ - if (x == Mono_Posix_Error_ETXTBSY) -#ifdef ETXTBSY - {*r = ETXTBSY; return 0;} -#else /* def ETXTBSY */ - {errno = EINVAL; return -1;} -#endif /* ndef ETXTBSY */ - if (x == Mono_Posix_Error_EUCLEAN) -#ifdef EUCLEAN - {*r = EUCLEAN; return 0;} -#else /* def EUCLEAN */ - {errno = EINVAL; return -1;} -#endif /* ndef EUCLEAN */ - if (x == Mono_Posix_Error_EUNATCH) -#ifdef EUNATCH - {*r = EUNATCH; return 0;} -#else /* def EUNATCH */ - {errno = EINVAL; return -1;} -#endif /* ndef EUNATCH */ - if (x == Mono_Posix_Error_EUSERS) -#ifdef EUSERS - {*r = EUSERS; return 0;} -#else /* def EUSERS */ - {errno = EINVAL; return -1;} -#endif /* ndef EUSERS */ - if (x == Mono_Posix_Error_EWOULDBLOCK) -#ifdef EWOULDBLOCK - {*r = EWOULDBLOCK; return 0;} -#else /* def EWOULDBLOCK */ - {errno = EINVAL; return -1;} -#endif /* ndef EWOULDBLOCK */ - if (x == Mono_Posix_Error_EXDEV) -#ifdef EXDEV - {*r = EXDEV; return 0;} -#else /* def EXDEV */ - {errno = EINVAL; return -1;} -#endif /* ndef EXDEV */ - if (x == Mono_Posix_Error_EXFULL) -#ifdef EXFULL - {*r = EXFULL; return 0;} -#else /* def EXFULL */ - {errno = EINVAL; return -1;} -#endif /* ndef EXFULL */ - errno = EINVAL; return -1; -} +/* returns the maximum value of @type as a guint64 */ +#define _cnm_integral_type_max(type) \ + (_cnm_integral_type_is_unsigned (type) \ + ? sizeof(type) == sizeof(gint8) \ + ? G_MAXUINT8 \ + : sizeof(type) == sizeof(gint16) \ + ? G_MAXUINT16 \ + : sizeof(type) == sizeof(gint32) \ + ? G_MAXUINT32 \ + : sizeof(type) == sizeof(gint64) \ + ? G_MAXUINT64 \ + : (g_assert_not_reached (), 0) \ + : sizeof(type) == sizeof(gint8) \ + ? G_MAXINT8 \ + : sizeof(type) == sizeof(gint16) \ + ? G_MAXINT16 \ + : sizeof(type) == sizeof(gint32) \ + ? G_MAXINT32 \ + : sizeof(type) == sizeof(gint64) \ + ? G_MAXINT64 \ + : (g_assert_not_reached (), 0)) -int Mono_Posix_ToError (int x, int *r) -{ - *r = 0; - if (x == 0) - return 0; -#ifdef E2BIG - if (x == E2BIG) - {*r = Mono_Posix_Error_E2BIG; return 0;} -#endif /* ndef E2BIG */ -#ifdef EACCES - if (x == EACCES) - {*r = Mono_Posix_Error_EACCES; return 0;} -#endif /* ndef EACCES */ -#ifdef EADDRINUSE - if (x == EADDRINUSE) - {*r = Mono_Posix_Error_EADDRINUSE; return 0;} -#endif /* ndef EADDRINUSE */ -#ifdef EADDRNOTAVAIL - if (x == EADDRNOTAVAIL) - {*r = Mono_Posix_Error_EADDRNOTAVAIL; return 0;} -#endif /* ndef EADDRNOTAVAIL */ -#ifdef EADV - if (x == EADV) - {*r = Mono_Posix_Error_EADV; return 0;} -#endif /* ndef EADV */ -#ifdef EAFNOSUPPORT - if (x == EAFNOSUPPORT) - {*r = Mono_Posix_Error_EAFNOSUPPORT; return 0;} -#endif /* ndef EAFNOSUPPORT */ -#ifdef EAGAIN - if (x == EAGAIN) - {*r = Mono_Posix_Error_EAGAIN; return 0;} -#endif /* ndef EAGAIN */ -#ifdef EALREADY - if (x == EALREADY) - {*r = Mono_Posix_Error_EALREADY; return 0;} -#endif /* ndef EALREADY */ -#ifdef EBADE - if (x == EBADE) - {*r = Mono_Posix_Error_EBADE; return 0;} -#endif /* ndef EBADE */ -#ifdef EBADF - if (x == EBADF) - {*r = Mono_Posix_Error_EBADF; return 0;} -#endif /* ndef EBADF */ -#ifdef EBADFD - if (x == EBADFD) - {*r = Mono_Posix_Error_EBADFD; return 0;} -#endif /* ndef EBADFD */ -#ifdef EBADMSG - if (x == EBADMSG) - {*r = Mono_Posix_Error_EBADMSG; return 0;} -#endif /* ndef EBADMSG */ -#ifdef EBADR - if (x == EBADR) - {*r = Mono_Posix_Error_EBADR; return 0;} -#endif /* ndef EBADR */ -#ifdef EBADRQC - if (x == EBADRQC) - {*r = Mono_Posix_Error_EBADRQC; return 0;} -#endif /* ndef EBADRQC */ -#ifdef EBADSLT - if (x == EBADSLT) - {*r = Mono_Posix_Error_EBADSLT; return 0;} -#endif /* ndef EBADSLT */ -#ifdef EBFONT - if (x == EBFONT) - {*r = Mono_Posix_Error_EBFONT; return 0;} -#endif /* ndef EBFONT */ -#ifdef EBUSY - if (x == EBUSY) - {*r = Mono_Posix_Error_EBUSY; return 0;} -#endif /* ndef EBUSY */ -#ifdef ECHILD - if (x == ECHILD) - {*r = Mono_Posix_Error_ECHILD; return 0;} -#endif /* ndef ECHILD */ -#ifdef ECHRNG - if (x == ECHRNG) - {*r = Mono_Posix_Error_ECHRNG; return 0;} -#endif /* ndef ECHRNG */ -#ifdef ECOMM - if (x == ECOMM) - {*r = Mono_Posix_Error_ECOMM; return 0;} -#endif /* ndef ECOMM */ -#ifdef ECONNABORTED - if (x == ECONNABORTED) - {*r = Mono_Posix_Error_ECONNABORTED; return 0;} -#endif /* ndef ECONNABORTED */ -#ifdef ECONNREFUSED - if (x == ECONNREFUSED) - {*r = Mono_Posix_Error_ECONNREFUSED; return 0;} -#endif /* ndef ECONNREFUSED */ -#ifdef ECONNRESET - if (x == ECONNRESET) - {*r = Mono_Posix_Error_ECONNRESET; return 0;} -#endif /* ndef ECONNRESET */ -#ifdef EDEADLK - if (x == EDEADLK) - {*r = Mono_Posix_Error_EDEADLK; return 0;} -#endif /* ndef EDEADLK */ -#ifdef EDEADLOCK - if (x == EDEADLOCK) - {*r = Mono_Posix_Error_EDEADLOCK; return 0;} -#endif /* ndef EDEADLOCK */ -#ifdef EDESTADDRREQ - if (x == EDESTADDRREQ) - {*r = Mono_Posix_Error_EDESTADDRREQ; return 0;} -#endif /* ndef EDESTADDRREQ */ -#ifdef EDOM - if (x == EDOM) - {*r = Mono_Posix_Error_EDOM; return 0;} -#endif /* ndef EDOM */ -#ifdef EDOTDOT - if (x == EDOTDOT) - {*r = Mono_Posix_Error_EDOTDOT; return 0;} -#endif /* ndef EDOTDOT */ -#ifdef EDQUOT - if (x == EDQUOT) - {*r = Mono_Posix_Error_EDQUOT; return 0;} -#endif /* ndef EDQUOT */ -#ifdef EEXIST - if (x == EEXIST) - {*r = Mono_Posix_Error_EEXIST; return 0;} -#endif /* ndef EEXIST */ -#ifdef EFAULT - if (x == EFAULT) - {*r = Mono_Posix_Error_EFAULT; return 0;} -#endif /* ndef EFAULT */ -#ifdef EFBIG - if (x == EFBIG) - {*r = Mono_Posix_Error_EFBIG; return 0;} -#endif /* ndef EFBIG */ -#ifdef EHOSTDOWN - if (x == EHOSTDOWN) - {*r = Mono_Posix_Error_EHOSTDOWN; return 0;} -#endif /* ndef EHOSTDOWN */ -#ifdef EHOSTUNREACH - if (x == EHOSTUNREACH) - {*r = Mono_Posix_Error_EHOSTUNREACH; return 0;} -#endif /* ndef EHOSTUNREACH */ -#ifdef EIDRM - if (x == EIDRM) - {*r = Mono_Posix_Error_EIDRM; return 0;} -#endif /* ndef EIDRM */ -#ifdef EILSEQ - if (x == EILSEQ) - {*r = Mono_Posix_Error_EILSEQ; return 0;} -#endif /* ndef EILSEQ */ -#ifdef EINPROGRESS - if (x == EINPROGRESS) - {*r = Mono_Posix_Error_EINPROGRESS; return 0;} -#endif /* ndef EINPROGRESS */ -#ifdef EINTR - if (x == EINTR) - {*r = Mono_Posix_Error_EINTR; return 0;} -#endif /* ndef EINTR */ -#ifdef EINVAL - if (x == EINVAL) - {*r = Mono_Posix_Error_EINVAL; return 0;} -#endif /* ndef EINVAL */ -#ifdef EIO - if (x == EIO) - {*r = Mono_Posix_Error_EIO; return 0;} -#endif /* ndef EIO */ -#ifdef EISCONN - if (x == EISCONN) - {*r = Mono_Posix_Error_EISCONN; return 0;} -#endif /* ndef EISCONN */ -#ifdef EISDIR - if (x == EISDIR) - {*r = Mono_Posix_Error_EISDIR; return 0;} -#endif /* ndef EISDIR */ -#ifdef EISNAM - if (x == EISNAM) - {*r = Mono_Posix_Error_EISNAM; return 0;} -#endif /* ndef EISNAM */ -#ifdef EL2HLT - if (x == EL2HLT) - {*r = Mono_Posix_Error_EL2HLT; return 0;} -#endif /* ndef EL2HLT */ -#ifdef EL2NSYNC - if (x == EL2NSYNC) - {*r = Mono_Posix_Error_EL2NSYNC; return 0;} -#endif /* ndef EL2NSYNC */ -#ifdef EL3HLT - if (x == EL3HLT) - {*r = Mono_Posix_Error_EL3HLT; return 0;} -#endif /* ndef EL3HLT */ -#ifdef EL3RST - if (x == EL3RST) - {*r = Mono_Posix_Error_EL3RST; return 0;} -#endif /* ndef EL3RST */ -#ifdef ELIBACC - if (x == ELIBACC) - {*r = Mono_Posix_Error_ELIBACC; return 0;} -#endif /* ndef ELIBACC */ -#ifdef ELIBBAD - if (x == ELIBBAD) - {*r = Mono_Posix_Error_ELIBBAD; return 0;} -#endif /* ndef ELIBBAD */ -#ifdef ELIBEXEC - if (x == ELIBEXEC) - {*r = Mono_Posix_Error_ELIBEXEC; return 0;} -#endif /* ndef ELIBEXEC */ -#ifdef ELIBMAX - if (x == ELIBMAX) - {*r = Mono_Posix_Error_ELIBMAX; return 0;} -#endif /* ndef ELIBMAX */ -#ifdef ELIBSCN - if (x == ELIBSCN) - {*r = Mono_Posix_Error_ELIBSCN; return 0;} -#endif /* ndef ELIBSCN */ -#ifdef ELNRNG - if (x == ELNRNG) - {*r = Mono_Posix_Error_ELNRNG; return 0;} -#endif /* ndef ELNRNG */ -#ifdef ELOOP - if (x == ELOOP) - {*r = Mono_Posix_Error_ELOOP; return 0;} -#endif /* ndef ELOOP */ -#ifdef EMEDIUMTYPE - if (x == EMEDIUMTYPE) - {*r = Mono_Posix_Error_EMEDIUMTYPE; return 0;} -#endif /* ndef EMEDIUMTYPE */ -#ifdef EMFILE - if (x == EMFILE) - {*r = Mono_Posix_Error_EMFILE; return 0;} -#endif /* ndef EMFILE */ -#ifdef EMLINK - if (x == EMLINK) - {*r = Mono_Posix_Error_EMLINK; return 0;} -#endif /* ndef EMLINK */ -#ifdef EMSGSIZE - if (x == EMSGSIZE) - {*r = Mono_Posix_Error_EMSGSIZE; return 0;} -#endif /* ndef EMSGSIZE */ -#ifdef EMULTIHOP - if (x == EMULTIHOP) - {*r = Mono_Posix_Error_EMULTIHOP; return 0;} -#endif /* ndef EMULTIHOP */ -#ifdef ENAMETOOLONG - if (x == ENAMETOOLONG) - {*r = Mono_Posix_Error_ENAMETOOLONG; return 0;} -#endif /* ndef ENAMETOOLONG */ -#ifdef ENAVAIL - if (x == ENAVAIL) - {*r = Mono_Posix_Error_ENAVAIL; return 0;} -#endif /* ndef ENAVAIL */ -#ifdef ENETDOWN - if (x == ENETDOWN) - {*r = Mono_Posix_Error_ENETDOWN; return 0;} -#endif /* ndef ENETDOWN */ -#ifdef ENETRESET - if (x == ENETRESET) - {*r = Mono_Posix_Error_ENETRESET; return 0;} -#endif /* ndef ENETRESET */ -#ifdef ENETUNREACH - if (x == ENETUNREACH) - {*r = Mono_Posix_Error_ENETUNREACH; return 0;} -#endif /* ndef ENETUNREACH */ -#ifdef ENFILE - if (x == ENFILE) - {*r = Mono_Posix_Error_ENFILE; return 0;} -#endif /* ndef ENFILE */ -#ifdef ENOANO - if (x == ENOANO) - {*r = Mono_Posix_Error_ENOANO; return 0;} -#endif /* ndef ENOANO */ -#ifdef ENOBUFS - if (x == ENOBUFS) - {*r = Mono_Posix_Error_ENOBUFS; return 0;} -#endif /* ndef ENOBUFS */ -#ifdef ENOCSI - if (x == ENOCSI) - {*r = Mono_Posix_Error_ENOCSI; return 0;} -#endif /* ndef ENOCSI */ -#ifdef ENODATA - if (x == ENODATA) - {*r = Mono_Posix_Error_ENODATA; return 0;} -#endif /* ndef ENODATA */ -#ifdef ENODEV - if (x == ENODEV) - {*r = Mono_Posix_Error_ENODEV; return 0;} -#endif /* ndef ENODEV */ -#ifdef ENOENT - if (x == ENOENT) - {*r = Mono_Posix_Error_ENOENT; return 0;} -#endif /* ndef ENOENT */ -#ifdef ENOEXEC - if (x == ENOEXEC) - {*r = Mono_Posix_Error_ENOEXEC; return 0;} -#endif /* ndef ENOEXEC */ -#ifdef ENOLCK - if (x == ENOLCK) - {*r = Mono_Posix_Error_ENOLCK; return 0;} -#endif /* ndef ENOLCK */ -#ifdef ENOLINK - if (x == ENOLINK) - {*r = Mono_Posix_Error_ENOLINK; return 0;} -#endif /* ndef ENOLINK */ -#ifdef ENOMEDIUM - if (x == ENOMEDIUM) - {*r = Mono_Posix_Error_ENOMEDIUM; return 0;} -#endif /* ndef ENOMEDIUM */ -#ifdef ENOMEM - if (x == ENOMEM) - {*r = Mono_Posix_Error_ENOMEM; return 0;} -#endif /* ndef ENOMEM */ -#ifdef ENOMSG - if (x == ENOMSG) - {*r = Mono_Posix_Error_ENOMSG; return 0;} -#endif /* ndef ENOMSG */ -#ifdef ENONET - if (x == ENONET) - {*r = Mono_Posix_Error_ENONET; return 0;} -#endif /* ndef ENONET */ -#ifdef ENOPKG - if (x == ENOPKG) - {*r = Mono_Posix_Error_ENOPKG; return 0;} -#endif /* ndef ENOPKG */ -#ifdef ENOPROTOOPT - if (x == ENOPROTOOPT) - {*r = Mono_Posix_Error_ENOPROTOOPT; return 0;} -#endif /* ndef ENOPROTOOPT */ -#ifdef ENOSPC - if (x == ENOSPC) - {*r = Mono_Posix_Error_ENOSPC; return 0;} -#endif /* ndef ENOSPC */ -#ifdef ENOSR - if (x == ENOSR) - {*r = Mono_Posix_Error_ENOSR; return 0;} -#endif /* ndef ENOSR */ -#ifdef ENOSTR - if (x == ENOSTR) - {*r = Mono_Posix_Error_ENOSTR; return 0;} -#endif /* ndef ENOSTR */ -#ifdef ENOSYS - if (x == ENOSYS) - {*r = Mono_Posix_Error_ENOSYS; return 0;} -#endif /* ndef ENOSYS */ -#ifdef ENOTBLK - if (x == ENOTBLK) - {*r = Mono_Posix_Error_ENOTBLK; return 0;} -#endif /* ndef ENOTBLK */ -#ifdef ENOTCONN - if (x == ENOTCONN) - {*r = Mono_Posix_Error_ENOTCONN; return 0;} -#endif /* ndef ENOTCONN */ -#ifdef ENOTDIR - if (x == ENOTDIR) - {*r = Mono_Posix_Error_ENOTDIR; return 0;} -#endif /* ndef ENOTDIR */ -#ifdef ENOTEMPTY - if (x == ENOTEMPTY) - {*r = Mono_Posix_Error_ENOTEMPTY; return 0;} -#endif /* ndef ENOTEMPTY */ -#ifdef ENOTNAM - if (x == ENOTNAM) - {*r = Mono_Posix_Error_ENOTNAM; return 0;} -#endif /* ndef ENOTNAM */ -#ifdef ENOTSOCK - if (x == ENOTSOCK) - {*r = Mono_Posix_Error_ENOTSOCK; return 0;} -#endif /* ndef ENOTSOCK */ -#ifdef ENOTTY - if (x == ENOTTY) - {*r = Mono_Posix_Error_ENOTTY; return 0;} -#endif /* ndef ENOTTY */ -#ifdef ENOTUNIQ - if (x == ENOTUNIQ) - {*r = Mono_Posix_Error_ENOTUNIQ; return 0;} -#endif /* ndef ENOTUNIQ */ -#ifdef ENXIO - if (x == ENXIO) - {*r = Mono_Posix_Error_ENXIO; return 0;} -#endif /* ndef ENXIO */ -#ifdef EOPNOTSUPP - if (x == EOPNOTSUPP) - {*r = Mono_Posix_Error_EOPNOTSUPP; return 0;} -#endif /* ndef EOPNOTSUPP */ -#ifdef EOVERFLOW - if (x == EOVERFLOW) - {*r = Mono_Posix_Error_EOVERFLOW; return 0;} -#endif /* ndef EOVERFLOW */ -#ifdef EPERM - if (x == EPERM) - {*r = Mono_Posix_Error_EPERM; return 0;} -#endif /* ndef EPERM */ -#ifdef EPFNOSUPPORT - if (x == EPFNOSUPPORT) - {*r = Mono_Posix_Error_EPFNOSUPPORT; return 0;} -#endif /* ndef EPFNOSUPPORT */ -#ifdef EPIPE - if (x == EPIPE) - {*r = Mono_Posix_Error_EPIPE; return 0;} -#endif /* ndef EPIPE */ -#ifdef EPROTO - if (x == EPROTO) - {*r = Mono_Posix_Error_EPROTO; return 0;} -#endif /* ndef EPROTO */ -#ifdef EPROTONOSUPPORT - if (x == EPROTONOSUPPORT) - {*r = Mono_Posix_Error_EPROTONOSUPPORT; return 0;} -#endif /* ndef EPROTONOSUPPORT */ -#ifdef EPROTOTYPE - if (x == EPROTOTYPE) - {*r = Mono_Posix_Error_EPROTOTYPE; return 0;} -#endif /* ndef EPROTOTYPE */ -#ifdef ERANGE - if (x == ERANGE) - {*r = Mono_Posix_Error_ERANGE; return 0;} -#endif /* ndef ERANGE */ -#ifdef EREMCHG - if (x == EREMCHG) - {*r = Mono_Posix_Error_EREMCHG; return 0;} -#endif /* ndef EREMCHG */ -#ifdef EREMOTE - if (x == EREMOTE) - {*r = Mono_Posix_Error_EREMOTE; return 0;} -#endif /* ndef EREMOTE */ -#ifdef EREMOTEIO - if (x == EREMOTEIO) - {*r = Mono_Posix_Error_EREMOTEIO; return 0;} -#endif /* ndef EREMOTEIO */ -#ifdef ERESTART - if (x == ERESTART) - {*r = Mono_Posix_Error_ERESTART; return 0;} -#endif /* ndef ERESTART */ -#ifdef EROFS - if (x == EROFS) - {*r = Mono_Posix_Error_EROFS; return 0;} -#endif /* ndef EROFS */ -#ifdef ESHUTDOWN - if (x == ESHUTDOWN) - {*r = Mono_Posix_Error_ESHUTDOWN; return 0;} -#endif /* ndef ESHUTDOWN */ -#ifdef ESOCKTNOSUPPORT - if (x == ESOCKTNOSUPPORT) - {*r = Mono_Posix_Error_ESOCKTNOSUPPORT; return 0;} -#endif /* ndef ESOCKTNOSUPPORT */ -#ifdef ESPIPE - if (x == ESPIPE) - {*r = Mono_Posix_Error_ESPIPE; return 0;} -#endif /* ndef ESPIPE */ -#ifdef ESRCH - if (x == ESRCH) - {*r = Mono_Posix_Error_ESRCH; return 0;} -#endif /* ndef ESRCH */ -#ifdef ESRMNT - if (x == ESRMNT) - {*r = Mono_Posix_Error_ESRMNT; return 0;} -#endif /* ndef ESRMNT */ -#ifdef ESTALE - if (x == ESTALE) - {*r = Mono_Posix_Error_ESTALE; return 0;} -#endif /* ndef ESTALE */ -#ifdef ESTRPIPE - if (x == ESTRPIPE) - {*r = Mono_Posix_Error_ESTRPIPE; return 0;} -#endif /* ndef ESTRPIPE */ -#ifdef ETIME - if (x == ETIME) - {*r = Mono_Posix_Error_ETIME; return 0;} -#endif /* ndef ETIME */ -#ifdef ETIMEDOUT - if (x == ETIMEDOUT) - {*r = Mono_Posix_Error_ETIMEDOUT; return 0;} -#endif /* ndef ETIMEDOUT */ -#ifdef ETOOMANYREFS - if (x == ETOOMANYREFS) - {*r = Mono_Posix_Error_ETOOMANYREFS; return 0;} -#endif /* ndef ETOOMANYREFS */ -#ifdef ETXTBSY - if (x == ETXTBSY) - {*r = Mono_Posix_Error_ETXTBSY; return 0;} -#endif /* ndef ETXTBSY */ -#ifdef EUCLEAN - if (x == EUCLEAN) - {*r = Mono_Posix_Error_EUCLEAN; return 0;} -#endif /* ndef EUCLEAN */ -#ifdef EUNATCH - if (x == EUNATCH) - {*r = Mono_Posix_Error_EUNATCH; return 0;} -#endif /* ndef EUNATCH */ -#ifdef EUSERS - if (x == EUSERS) - {*r = Mono_Posix_Error_EUSERS; return 0;} -#endif /* ndef EUSERS */ -#ifdef EWOULDBLOCK - if (x == EWOULDBLOCK) - {*r = Mono_Posix_Error_EWOULDBLOCK; return 0;} -#endif /* ndef EWOULDBLOCK */ -#ifdef EXDEV - if (x == EXDEV) - {*r = Mono_Posix_Error_EXDEV; return 0;} -#endif /* ndef EXDEV */ -#ifdef EXFULL - if (x == EXFULL) - {*r = Mono_Posix_Error_EXFULL; return 0;} -#endif /* ndef EXFULL */ - errno = EINVAL; return -1; -} +#ifdef DEBUG +#define _cnm_dump_(to_t,from) \ + printf ("# %s -> %s: min=%llx; max=%llx; value=%llx; lt=%i; l0=%i; gt=%i; e=%i\n", \ + #from, #to_t, \ + (gint64) (_cnm_integral_type_min(to_t)), \ + (gint64) (_cnm_integral_type_max (to_t)), \ + (gint64) (from), \ + (_cnm_integral_type_min (to_t) <= from), \ + (from < 0), \ + /* (_cnm_integral_type_max (to_t) >= from) */ \ + (from <= _cnm_integral_type_max (to_t)), \ + ((_cnm_integral_type_min(to_t) >= from) && \ + ((from < 0) ? 1 : (from <= _cnm_integral_type_max(to_t)))) \ + ) +#else +#define _cnm_dump_(to_t, from) do {} while (0) +#endif -int Mono_Posix_FromMmapProt (int x, int *r) -{ - *r = 0; - if (x == 0) - return 0; - if ((x & Mono_Posix_MmapProt_PROT_EXEC) == Mono_Posix_MmapProt_PROT_EXEC) -#ifdef PROT_EXEC - *r |= PROT_EXEC; -#else /* def PROT_EXEC */ - {errno = EINVAL; return -1;} -#endif /* ndef PROT_EXEC */ - if ((x & Mono_Posix_MmapProt_PROT_GROWSDOWN) == Mono_Posix_MmapProt_PROT_GROWSDOWN) -#ifdef PROT_GROWSDOWN - *r |= PROT_GROWSDOWN; -#else /* def PROT_GROWSDOWN */ - {errno = EINVAL; return -1;} -#endif /* ndef PROT_GROWSDOWN */ - if ((x & Mono_Posix_MmapProt_PROT_GROWSUP) == Mono_Posix_MmapProt_PROT_GROWSUP) -#ifdef PROT_GROWSUP - *r |= PROT_GROWSUP; -#else /* def PROT_GROWSUP */ - {errno = EINVAL; return -1;} -#endif /* ndef PROT_GROWSUP */ - if ((x & Mono_Posix_MmapProt_PROT_NONE) == Mono_Posix_MmapProt_PROT_NONE) -#ifdef PROT_NONE - *r |= PROT_NONE; -#else /* def PROT_NONE */ - {errno = EINVAL; return -1;} -#endif /* ndef PROT_NONE */ - if ((x & Mono_Posix_MmapProt_PROT_READ) == Mono_Posix_MmapProt_PROT_READ) -#ifdef PROT_READ - *r |= PROT_READ; -#else /* def PROT_READ */ - {errno = EINVAL; return -1;} -#endif /* ndef PROT_READ */ - if ((x & Mono_Posix_MmapProt_PROT_WRITE) == Mono_Posix_MmapProt_PROT_WRITE) -#ifdef PROT_WRITE - *r |= PROT_WRITE; -#else /* def PROT_WRITE */ - {errno = EINVAL; return -1;} -#endif /* ndef PROT_WRITE */ - return 0; -} +#define _cnm_return_val_if_overflow(to_t,from,val) G_STMT_START { \ + if (!(_cnm_integral_type_min(to_t) <= from && \ + ((from < 0) || (from <= _cnm_integral_type_max(to_t))))) { \ + _cnm_dump_(to_t, from); \ + errno = EOVERFLOW; \ + return (val); \ + } \ + } G_STMT_END -int Mono_Posix_ToMmapProt (int x, int *r) -{ - *r = 0; - if (x == 0) - return 0; -#ifdef PROT_EXEC - if ((x & PROT_EXEC) == PROT_EXEC) - *r |= Mono_Posix_MmapProt_PROT_EXEC; -#endif /* ndef PROT_EXEC */ -#ifdef PROT_GROWSDOWN - if ((x & PROT_GROWSDOWN) == PROT_GROWSDOWN) - *r |= Mono_Posix_MmapProt_PROT_GROWSDOWN; -#endif /* ndef PROT_GROWSDOWN */ -#ifdef PROT_GROWSUP - if ((x & PROT_GROWSUP) == PROT_GROWSUP) - *r |= Mono_Posix_MmapProt_PROT_GROWSUP; -#endif /* ndef PROT_GROWSUP */ -#ifdef PROT_NONE - if ((x & PROT_NONE) == PROT_NONE) - *r |= Mono_Posix_MmapProt_PROT_NONE; -#endif /* ndef PROT_NONE */ -#ifdef PROT_READ - if ((x & PROT_READ) == PROT_READ) - *r |= Mono_Posix_MmapProt_PROT_READ; -#endif /* ndef PROT_READ */ -#ifdef PROT_WRITE - if ((x & PROT_WRITE) == PROT_WRITE) - *r |= Mono_Posix_MmapProt_PROT_WRITE; -#endif /* ndef PROT_WRITE */ - return 0; -} - int Mono_Posix_FromAccessModes (int x, int *r) { *r = 0; - if (x == 0) - return 0; if ((x & Mono_Posix_AccessModes_F_OK) == Mono_Posix_AccessModes_F_OK) #ifdef F_OK *r |= F_OK; @@ -1917,6 +166,8 @@ #else /* def X_OK */ {errno = EINVAL; return -1;} #endif /* ndef X_OK */ + if (x == 0) + return 0; return 0; } @@ -1947,8 +198,6 @@ int Mono_Posix_FromConfstrName (int x, int *r) { *r = 0; - if (x == 0) - return 0; if (x == Mono_Posix_ConfstrName__CS_GNU_LIBC_VERSION) #ifdef _CS_GNU_LIBC_VERSION {*r = _CS_GNU_LIBC_VERSION; return 0;} @@ -2213,6 +462,8 @@ #else /* def _CS_XBS5_LPBIG_OFFBIG_LINTFLAGS */ {errno = EINVAL; return -1;} #endif /* ndef _CS_XBS5_LPBIG_OFFBIG_LINTFLAGS */ + if (x == 0) + return 0; errno = EINVAL; return -1; } @@ -2403,8 +654,6 @@ int Mono_Posix_FromDirectoryNotifyFlags (int x, int *r) { *r = 0; - if (x == 0) - return 0; if ((x & Mono_Posix_DirectoryNotifyFlags_DN_ACCESS) == Mono_Posix_DirectoryNotifyFlags_DN_ACCESS) #ifdef DN_ACCESS *r |= DN_ACCESS; @@ -2447,6 +696,8 @@ #else /* def DN_RENAME */ {errno = EINVAL; return -1;} #endif /* ndef DN_RENAME */ + if (x == 0) + return 0; return 0; } @@ -2489,8 +740,6 @@ int Mono_Posix_FromErrno (int x, int *r) { *r = 0; - if (x == 0) - return 0; if (x == Mono_Posix_Errno_E2BIG) #ifdef E2BIG {*r = E2BIG; return 0;} @@ -3235,6 +1484,8 @@ #else /* def EXFULL */ {errno = EINVAL; return -1;} #endif /* ndef EXFULL */ + if (x == 0) + return 0; errno = EINVAL; return -1; } @@ -3745,8 +1996,6 @@ int Mono_Posix_FromFcntlCommand (int x, int *r) { *r = 0; - if (x == 0) - return 0; if (x == Mono_Posix_FcntlCommand_F_DUPFD) #ifdef F_DUPFD {*r = F_DUPFD; return 0;} @@ -3837,6 +2086,8 @@ #else /* def F_SETSIG */ {errno = EINVAL; return -1;} #endif /* ndef F_SETSIG */ + if (x == 0) + return 0; errno = EINVAL; return -1; } @@ -3911,8 +2162,6 @@ int Mono_Posix_FromFilePermissions (unsigned int x, unsigned int *r) { *r = 0; - if (x == 0) - return 0; if ((x & Mono_Posix_FilePermissions_ACCESSPERMS) == Mono_Posix_FilePermissions_ACCESSPERMS) #ifdef ACCESSPERMS *r |= ACCESSPERMS; @@ -4069,6 +2318,8 @@ #else /* def S_IXUSR */ {errno = EINVAL; return -1;} #endif /* ndef S_IXUSR */ + if (x == 0) + return 0; return 0; } @@ -4187,8 +2438,6 @@ int Mono_Posix_FromLockType (short x, short *r) { *r = 0; - if (x == 0) - return 0; if (x == Mono_Posix_LockType_F_RDLCK) #ifdef F_RDLCK {*r = F_RDLCK; return 0;} @@ -4207,6 +2456,8 @@ #else /* def F_WRLCK */ {errno = EINVAL; return -1;} #endif /* ndef F_WRLCK */ + if (x == 0) + return 0; errno = EINVAL; return -1; } @@ -4233,8 +2484,6 @@ int Mono_Posix_FromLockfCommand (int x, int *r) { *r = 0; - if (x == 0) - return 0; if (x == Mono_Posix_LockfCommand_F_LOCK) #ifdef F_LOCK {*r = F_LOCK; return 0;} @@ -4259,6 +2508,8 @@ #else /* def F_ULOCK */ {errno = EINVAL; return -1;} #endif /* ndef F_ULOCK */ + if (x == 0) + return 0; errno = EINVAL; return -1; } @@ -4289,8 +2540,6 @@ int Mono_Posix_FromMlockallFlags (int x, int *r) { *r = 0; - if (x == 0) - return 0; if ((x & Mono_Posix_MlockallFlags_MCL_CURRENT) == Mono_Posix_MlockallFlags_MCL_CURRENT) #ifdef MCL_CURRENT *r |= MCL_CURRENT; @@ -4303,6 +2552,8 @@ #else /* def MCL_FUTURE */ {errno = EINVAL; return -1;} #endif /* ndef MCL_FUTURE */ + if (x == 0) + return 0; return 0; } @@ -4325,8 +2576,6 @@ int Mono_Posix_FromMmapFlags (int x, int *r) { *r = 0; - if (x == 0) - return 0; if ((x & Mono_Posix_MmapFlags_MAP_ANON) == Mono_Posix_MmapFlags_MAP_ANON) #ifdef MAP_ANON *r |= MAP_ANON; @@ -4411,6 +2660,8 @@ #else /* def MAP_TYPE */ {errno = EINVAL; return -1;} #endif /* ndef MAP_TYPE */ + if (x == 0) + return 0; return 0; } @@ -4481,8 +2732,6 @@ int Mono_Posix_FromMmapProts (int x, int *r) { *r = 0; - if (x == 0) - return 0; if ((x & Mono_Posix_MmapProts_PROT_EXEC) == Mono_Posix_MmapProts_PROT_EXEC) #ifdef PROT_EXEC *r |= PROT_EXEC; @@ -4519,6 +2768,8 @@ #else /* def PROT_WRITE */ {errno = EINVAL; return -1;} #endif /* ndef PROT_WRITE */ + if (x == 0) + return 0; return 0; } @@ -4557,8 +2808,6 @@ int Mono_Posix_FromMountFlags (guint64 x, guint64 *r) { *r = 0; - if (x == 0) - return 0; if ((x & Mono_Posix_MountFlags_ST_APPEND) == Mono_Posix_MountFlags_ST_APPEND) #ifdef ST_APPEND *r |= ST_APPEND; @@ -4619,6 +2868,8 @@ #else /* def ST_WRITE */ {errno = EINVAL; return -1;} #endif /* ndef ST_WRITE */ + if (x == 0) + return 0; return 0; } @@ -4673,14 +2924,14 @@ int Mono_Posix_FromMremapFlags (guint64 x, guint64 *r) { *r = 0; - if (x == 0) - return 0; if ((x & Mono_Posix_MremapFlags_MREMAP_MAYMOVE) == Mono_Posix_MremapFlags_MREMAP_MAYMOVE) #ifdef MREMAP_MAYMOVE *r |= MREMAP_MAYMOVE; #else /* def MREMAP_MAYMOVE */ {errno = EINVAL; return -1;} #endif /* ndef MREMAP_MAYMOVE */ + if (x == 0) + return 0; return 0; } @@ -4699,8 +2950,6 @@ int Mono_Posix_FromMsyncFlags (int x, int *r) { *r = 0; - if (x == 0) - return 0; if ((x & Mono_Posix_MsyncFlags_MS_ASYNC) == Mono_Posix_MsyncFlags_MS_ASYNC) #ifdef MS_ASYNC *r |= MS_ASYNC; @@ -4719,6 +2968,8 @@ #else /* def MS_SYNC */ {errno = EINVAL; return -1;} #endif /* ndef MS_SYNC */ + if (x == 0) + return 0; return 0; } @@ -4745,8 +2996,6 @@ int Mono_Posix_FromOpenFlags (int x, int *r) { *r = 0; - if (x == 0) - return 0; if ((x & Mono_Posix_OpenFlags_O_APPEND) == Mono_Posix_OpenFlags_O_APPEND) #ifdef O_APPEND *r |= O_APPEND; @@ -4837,6 +3086,8 @@ #else /* def O_WRONLY */ {errno = EINVAL; return -1;} #endif /* ndef O_WRONLY */ + if (x == 0) + return 0; return 0; } @@ -4911,8 +3162,6 @@ int Mono_Posix_FromPathconfName (int x, int *r) { *r = 0; - if (x == 0) - return 0; if (x == Mono_Posix_PathconfName__PC_2_SYMLINKS) #ifdef _PC_2_SYMLINKS {*r = _PC_2_SYMLINKS; return 0;} @@ -5039,6 +3288,8 @@ #else /* def _PC_VDISABLE */ {errno = EINVAL; return -1;} #endif /* ndef _PC_VDISABLE */ + if (x == 0) + return 0; errno = EINVAL; return -1; } @@ -5137,8 +3388,6 @@ int Mono_Posix_FromPollEvents (short x, short *r) { *r = 0; - if (x == 0) - return 0; if ((x & Mono_Posix_PollEvents_POLLERR) == Mono_Posix_PollEvents_POLLERR) #ifdef POLLERR *r |= POLLERR; @@ -5199,6 +3448,8 @@ #else /* def POLLWRNORM */ {errno = EINVAL; return -1;} #endif /* ndef POLLWRNORM */ + if (x == 0) + return 0; return 0; } @@ -5250,11 +3501,47 @@ return 0; } +int +Mono_Posix_FromPollfd (struct Mono_Posix_Pollfd *from, struct pollfd *to) +{ + _cnm_return_val_if_overflow (int, from->fd, -1); + + memset (to, 0, sizeof(*to)); + + to->fd = from->fd; + if (Mono_Posix_FromPollEvents (from->events, &to->events) != 0) { + return -1; + } + if (Mono_Posix_FromPollEvents (from->revents, &to->revents) != 0) { + return -1; + } + + return 0; +} + + +int +Mono_Posix_ToPollfd (struct pollfd *from, struct Mono_Posix_Pollfd *to) +{ + _cnm_return_val_if_overflow (int, from->fd, -1); + + memset (to, 0, sizeof(*to)); + + to->fd = from->fd; + if (Mono_Posix_ToPollEvents (from->events, &to->events) != 0) { + return -1; + } + if (Mono_Posix_ToPollEvents (from->revents, &to->revents) != 0) { + return -1; + } + + return 0; +} + + int Mono_Posix_FromPosixFadviseAdvice (int x, int *r) { *r = 0; - if (x == 0) - return 0; if (x == Mono_Posix_PosixFadviseAdvice_POSIX_FADV_DONTNEED) #ifdef POSIX_FADV_DONTNEED {*r = POSIX_FADV_DONTNEED; return 0;} @@ -5291,6 +3578,8 @@ #else /* def POSIX_FADV_WILLNEED */ {errno = EINVAL; return -1;} #endif /* ndef POSIX_FADV_WILLNEED */ + if (x == 0) + return 0; errno = EINVAL; return -1; } @@ -5329,8 +3618,6 @@ int Mono_Posix_FromPosixMadviseAdvice (int x, int *r) { *r = 0; - if (x == 0) - return 0; if (x == Mono_Posix_PosixMadviseAdvice_POSIX_MADV_DONTNEED) #ifdef POSIX_MADV_DONTNEED {*r = POSIX_MADV_DONTNEED; return 0;} @@ -5361,6 +3648,8 @@ #else /* def POSIX_MADV_WILLNEED */ {errno = EINVAL; return -1;} #endif /* ndef POSIX_MADV_WILLNEED */ + if (x == 0) + return 0; errno = EINVAL; return -1; } @@ -5395,8 +3684,6 @@ int Mono_Posix_FromSeekFlags (short x, short *r) { *r = 0; - if (x == 0) - return 0; if (x == Mono_Posix_SeekFlags_L_INCR) #ifdef L_INCR {*r = L_INCR; return 0;} @@ -5433,6 +3720,8 @@ #else /* def SEEK_SET */ {errno = EINVAL; return -1;} #endif /* ndef SEEK_SET */ + if (x == 0) + return 0; errno = EINVAL; return -1; } @@ -5471,8 +3760,6 @@ int Mono_Posix_FromSignum (int x, int *r) { *r = 0; - if (x == 0) - return 0; if (x == Mono_Posix_Signum_SIGABRT) #ifdef SIGABRT {*r = SIGABRT; return 0;} @@ -5683,6 +3970,8 @@ #else /* def SIGXFSZ */ {errno = EINVAL; return -1;} #endif /* ndef SIGXFSZ */ + if (x == 0) + return 0; errno = EINVAL; return -1; } @@ -5834,11 +4123,85 @@ errno = EINVAL; return -1; } +int +Mono_Posix_FromStat (struct Mono_Posix_Stat *from, struct stat *to) +{ + _cnm_return_val_if_overflow (dev_t, from->st_dev, -1); + _cnm_return_val_if_overflow (ino_t, from->st_ino, -1); + _cnm_return_val_if_overflow (nlink_t, from->st_nlink, -1); + _cnm_return_val_if_overflow (uid_t, from->st_uid, -1); + _cnm_return_val_if_overflow (gid_t, from->st_gid, -1); + _cnm_return_val_if_overflow (dev_t, from->st_rdev, -1); + _cnm_return_val_if_overflow (off_t, from->st_size, -1); + _cnm_return_val_if_overflow (blksize_t, from->st_blksize, -1); + _cnm_return_val_if_overflow (blkcnt_t, from->st_blocks, -1); + _cnm_return_val_if_overflow (time_t, from->st_atime_, -1); + _cnm_return_val_if_overflow (time_t, from->st_mtime_, -1); + _cnm_return_val_if_overflow (time_t, from->st_ctime_, -1); + + memset (to, 0, sizeof(*to)); + + to->st_dev = from->st_dev; + to->st_ino = from->st_ino; + if (Mono_Posix_FromFilePermissions (from->st_mode, &to->st_mode) != 0) { + return -1; + } + to->st_nlink = from->st_nlink; + to->st_uid = from->st_uid; + to->st_gid = from->st_gid; + to->st_rdev = from->st_rdev; + to->st_size = from->st_size; + to->st_blksize = from->st_blksize; + to->st_blocks = from->st_blocks; + to->st_atime = from->st_atime_; + to->st_mtime = from->st_mtime_; + to->st_ctime = from->st_ctime_; + + return 0; +} + + +int +Mono_Posix_ToStat (struct stat *from, struct Mono_Posix_Stat *to) +{ + _cnm_return_val_if_overflow (guint64, from->st_dev, -1); + _cnm_return_val_if_overflow (guint64, from->st_ino, -1); + _cnm_return_val_if_overflow (guint64, from->st_nlink, -1); + _cnm_return_val_if_overflow (unsigned int, from->st_uid, -1); + _cnm_return_val_if_overflow (unsigned int, from->st_gid, -1); + _cnm_return_val_if_overflow (guint64, from->st_rdev, -1); + _cnm_return_val_if_overflow (gint64, from->st_size, -1); + _cnm_return_val_if_overflow (gint64, from->st_blksize, -1); + _cnm_return_val_if_overflow (gint64, from->st_blocks, -1); + _cnm_return_val_if_overflow (gint64, from->st_atime, -1); + _cnm_return_val_if_overflow (gint64, from->st_mtime, -1); + _cnm_return_val_if_overflow (gint64, from->st_ctime, -1); + + memset (to, 0, sizeof(*to)); + + to->st_dev = from->st_dev; + to->st_ino = from->st_ino; + if (Mono_Posix_ToFilePermissions (from->st_mode, &to->st_mode) != 0) { + return -1; + } + to->st_nlink = from->st_nlink; + to->st_uid = from->st_uid; + to->st_gid = from->st_gid; + to->st_rdev = from->st_rdev; + to->st_size = from->st_size; + to->st_blksize = from->st_blksize; + to->st_blocks = from->st_blocks; + to->st_atime_ = from->st_atime; + to->st_mtime_ = from->st_mtime; + to->st_ctime_ = from->st_ctime; + + return 0; +} + + int Mono_Posix_FromSysconfName (int x, int *r) { *r = 0; - if (x == 0) - return 0; if (x == Mono_Posix_SysconfName__SC_2_CHAR_TERM) #ifdef _SC_2_CHAR_TERM {*r = _SC_2_CHAR_TERM; return 0;} @@ -7045,6 +5408,8 @@ #else /* def _SC_XOPEN_XPG4 */ {errno = EINVAL; return -1;} #endif /* ndef _SC_XOPEN_XPG4 */ + if (x == 0) + return 0; errno = EINVAL; return -1; } @@ -7863,8 +6228,6 @@ int Mono_Posix_FromSyslogFacility (int x, int *r) { *r = 0; - if (x == 0) - return 0; if (x == Mono_Posix_SyslogFacility_LOG_AUTH) #ifdef LOG_AUTH {*r = LOG_AUTH; return 0;} @@ -7985,6 +6348,8 @@ #else /* def LOG_UUCP */ {errno = EINVAL; return -1;} #endif /* ndef LOG_UUCP */ + if (x == 0) + return 0; errno = EINVAL; return -1; } @@ -8079,8 +6444,6 @@ int Mono_Posix_FromSyslogLevel (int x, int *r) { *r = 0; - if (x == 0) - return 0; if (x == Mono_Posix_SyslogLevel_LOG_ALERT) #ifdef LOG_ALERT {*r = LOG_ALERT; return 0;} @@ -8129,6 +6492,8 @@ #else /* def LOG_WARNING */ {errno = EINVAL; return -1;} #endif /* ndef LOG_WARNING */ + if (x == 0) + return 0; errno = EINVAL; return -1; } @@ -8175,8 +6540,6 @@ int Mono_Posix_FromSyslogOptions (int x, int *r) { *r = 0; - if (x == 0) - return 0; if ((x & Mono_Posix_SyslogOptions_LOG_CONS) == Mono_Posix_SyslogOptions_LOG_CONS) #ifdef LOG_CONS *r |= LOG_CONS; @@ -8213,6 +6576,8 @@ #else /* def LOG_PID */ {errno = EINVAL; return -1;} #endif /* ndef LOG_PID */ + if (x == 0) + return 0; return 0; } @@ -8248,11 +6613,69 @@ return 0; } +int +Mono_Posix_FromTimeval (struct Mono_Posix_Timeval *from, struct timeval *to) +{ + _cnm_return_val_if_overflow (time_t, from->tv_sec, -1); + _cnm_return_val_if_overflow (suseconds_t, from->tv_usec, -1); + + memset (to, 0, sizeof(*to)); + + to->tv_sec = from->tv_sec; + to->tv_usec = from->tv_usec; + + return 0; +} + + +int +Mono_Posix_ToTimeval (struct timeval *from, struct Mono_Posix_Timeval *to) +{ + _cnm_return_val_if_overflow (gint64, from->tv_sec, -1); + _cnm_return_val_if_overflow (gint64, from->tv_usec, -1); + + memset (to, 0, sizeof(*to)); + + to->tv_sec = from->tv_sec; + to->tv_usec = from->tv_usec; + + return 0; +} + + +int +Mono_Posix_FromTimezone (struct Mono_Posix_Timezone *from, struct timezone *to) +{ + _cnm_return_val_if_overflow (int, from->tz_minuteswest, -1); + _cnm_return_val_if_overflow (int, from->tz_dsttime, -1); + + memset (to, 0, sizeof(*to)); + + to->tz_minuteswest = from->tz_minuteswest; + to->tz_dsttime = from->tz_dsttime; + + return 0; +} + + +int +Mono_Posix_ToTimezone (struct timezone *from, struct Mono_Posix_Timezone *to) +{ + _cnm_return_val_if_overflow (int, from->tz_minuteswest, -1); + _cnm_return_val_if_overflow (int, from->tz_dsttime, -1); + + memset (to, 0, sizeof(*to)); + + to->tz_minuteswest = from->tz_minuteswest; + to->tz_dsttime = from->tz_dsttime; + + return 0; +} + + int Mono_Posix_FromWaitOptions (int x, int *r) { *r = 0; - if (x == 0) - return 0; if ((x & Mono_Posix_WaitOptions_WNOHANG) == Mono_Posix_WaitOptions_WNOHANG) #ifdef WNOHANG *r |= WNOHANG; @@ -8265,6 +6688,8 @@ #else /* def WUNTRACED */ {errno = EINVAL; return -1;} #endif /* ndef WUNTRACED */ + if (x == 0) + return 0; return 0; } @@ -8287,8 +6712,6 @@ int Mono_Posix_FromXattrFlags (int x, int *r) { *r = 0; - if (x == 0) - return 0; if ((x & Mono_Posix_XattrFlags_XATTR_AUTO) == Mono_Posix_XattrFlags_XATTR_AUTO) #ifdef XATTR_AUTO *r |= XATTR_AUTO; @@ -8307,6 +6730,8 @@ #else /* def XATTR_REPLACE */ {errno = EINVAL; return -1;} #endif /* ndef XATTR_REPLACE */ + if (x == 0) + return 0; return 0; } @@ -8330,2255 +6755,3 @@ return 0; } -int Mono_Posix_FromPathConf (int x, int *r) -{ - *r = 0; - if (x == 0) - return 0; - if (x == Mono_Posix_PathConf__PC_2_SYMLINKS) -#ifdef _PC_2_SYMLINKS - {*r = _PC_2_SYMLINKS; return 0;} -#else /* def _PC_2_SYMLINKS */ - {errno = EINVAL; return -1;} -#endif /* ndef _PC_2_SYMLINKS */ - if (x == Mono_Posix_PathConf__PC_ALLOC_SIZE_MIN) -#ifdef _PC_ALLOC_SIZE_MIN - {*r = _PC_ALLOC_SIZE_MIN; return 0;} -#else /* def _PC_ALLOC_SIZE_MIN */ - {errno = EINVAL; return -1;} -#endif /* ndef _PC_ALLOC_SIZE_MIN */ - if (x == Mono_Posix_PathConf__PC_ASYNC_IO) -#ifdef _PC_ASYNC_IO - {*r = _PC_ASYNC_IO; return 0;} -#else /* def _PC_ASYNC_IO */ - {errno = EINVAL; return -1;} -#endif /* ndef _PC_ASYNC_IO */ - if (x == Mono_Posix_PathConf__PC_CHOWN_RESTRICTED) -#ifdef _PC_CHOWN_RESTRICTED - {*r = _PC_CHOWN_RESTRICTED; return 0;} -#else /* def _PC_CHOWN_RESTRICTED */ - {errno = EINVAL; return -1;} -#endif /* ndef _PC_CHOWN_RESTRICTED */ - if (x == Mono_Posix_PathConf__PC_FILESIZEBITS) -#ifdef _PC_FILESIZEBITS - {*r = _PC_FILESIZEBITS; return 0;} -#else /* def _PC_FILESIZEBITS */ - {errno = EINVAL; return -1;} -#endif /* ndef _PC_FILESIZEBITS */ - if (x == Mono_Posix_PathConf__PC_LINK_MAX) -#ifdef _PC_LINK_MAX - {*r = _PC_LINK_MAX; return 0;} -#else /* def _PC_LINK_MAX */ - {errno = EINVAL; return -1;} -#endif /* ndef _PC_LINK_MAX */ - if (x == Mono_Posix_PathConf__PC_MAX_CANON) -#ifdef _PC_MAX_CANON - {*r = _PC_MAX_CANON; return 0;} -#else /* def _PC_MAX_CANON */ - {errno = EINVAL; return -1;} -#endif /* ndef _PC_MAX_CANON */ - if (x == Mono_Posix_PathConf__PC_MAX_INPUT) -#ifdef _PC_MAX_INPUT - {*r = _PC_MAX_INPUT; return 0;} -#else /* def _PC_MAX_INPUT */ - {errno = EINVAL; return -1;} -#endif /* ndef _PC_MAX_INPUT */ - if (x == Mono_Posix_PathConf__PC_NAME_MAX) -#ifdef _PC_NAME_MAX - {*r = _PC_NAME_MAX; return 0;} -#else /* def _PC_NAME_MAX */ - {errno = EINVAL; return -1;} -#endif /* ndef _PC_NAME_MAX */ - if (x == Mono_Posix_PathConf__PC_NO_TRUNC) -#ifdef _PC_NO_TRUNC - {*r = _PC_NO_TRUNC; return 0;} -#else /* def _PC_NO_TRUNC */ - {errno = EINVAL; return -1;} -#endif /* ndef _PC_NO_TRUNC */ - if (x == Mono_Posix_PathConf__PC_PATH_MAX) -#ifdef _PC_PATH_MAX - {*r = _PC_PATH_MAX; return 0;} -#else /* def _PC_PATH_MAX */ - {errno = EINVAL; return -1;} -#endif /* ndef _PC_PATH_MAX */ - if (x == Mono_Posix_PathConf__PC_PIPE_BUF) -#ifdef _PC_PIPE_BUF - {*r = _PC_PIPE_BUF; return 0;} -#else /* def _PC_PIPE_BUF */ - {errno = EINVAL; return -1;} -#endif /* ndef _PC_PIPE_BUF */ - if (x == Mono_Posix_PathConf__PC_PRIO_IO) -#ifdef _PC_PRIO_IO - {*r = _PC_PRIO_IO; return 0;} -#else /* def _PC_PRIO_IO */ - {errno = EINVAL; return -1;} -#endif /* ndef _PC_PRIO_IO */ - if (x == Mono_Posix_PathConf__PC_REC_INCR_XFER_SIZE) -#ifdef _PC_REC_INCR_XFER_SIZE - {*r = _PC_REC_INCR_XFER_SIZE; return 0;} -#else /* def _PC_REC_INCR_XFER_SIZE */ - {errno = EINVAL; return -1;} -#endif /* ndef _PC_REC_INCR_XFER_SIZE */ - if (x == Mono_Posix_PathConf__PC_REC_MAX_XFER_SIZE) -#ifdef _PC_REC_MAX_XFER_SIZE - {*r = _PC_REC_MAX_XFER_SIZE; return 0;} -#else /* def _PC_REC_MAX_XFER_SIZE */ - {errno = EINVAL; return -1;} -#endif /* ndef _PC_REC_MAX_XFER_SIZE */ - if (x == Mono_Posix_PathConf__PC_REC_MIN_XFER_SIZE) -#ifdef _PC_REC_MIN_XFER_SIZE - {*r = _PC_REC_MIN_XFER_SIZE; return 0;} -#else /* def _PC_REC_MIN_XFER_SIZE */ - {errno = EINVAL; return -1;} -#endif /* ndef _PC_REC_MIN_XFER_SIZE */ - if (x == Mono_Posix_PathConf__PC_REC_XFER_ALIGN) -#ifdef _PC_REC_XFER_ALIGN - {*r = _PC_REC_XFER_ALIGN; return 0;} -#else /* def _PC_REC_XFER_ALIGN */ - {errno = EINVAL; return -1;} -#endif /* ndef _PC_REC_XFER_ALIGN */ - if (x == Mono_Posix_PathConf__PC_SOCK_MAXBUF) -#ifdef _PC_SOCK_MAXBUF - {*r = _PC_SOCK_MAXBUF; return 0;} -#else /* def _PC_SOCK_MAXBUF */ - {errno = EINVAL; return -1;} -#endif /* ndef _PC_SOCK_MAXBUF */ - if (x == Mono_Posix_PathConf__PC_SYMLINK_MAX) -#ifdef _PC_SYMLINK_MAX - {*r = _PC_SYMLINK_MAX; return 0;} -#else /* def _PC_SYMLINK_MAX */ - {errno = EINVAL; return -1;} -#endif /* ndef _PC_SYMLINK_MAX */ - if (x == Mono_Posix_PathConf__PC_SYNC_IO) -#ifdef _PC_SYNC_IO - {*r = _PC_SYNC_IO; return 0;} -#else /* def _PC_SYNC_IO */ - {errno = EINVAL; return -1;} -#endif /* ndef _PC_SYNC_IO */ - if (x == Mono_Posix_PathConf__PC_VDISABLE) -#ifdef _PC_VDISABLE - {*r = _PC_VDISABLE; return 0;} -#else /* def _PC_VDISABLE */ - {errno = EINVAL; return -1;} -#endif /* ndef _PC_VDISABLE */ - errno = EINVAL; return -1; -} - -int Mono_Posix_ToPathConf (int x, int *r) -{ - *r = 0; - if (x == 0) - return 0; -#ifdef _PC_2_SYMLINKS - if (x == _PC_2_SYMLINKS) - {*r = Mono_Posix_PathConf__PC_2_SYMLINKS; return 0;} -#endif /* ndef _PC_2_SYMLINKS */ -#ifdef _PC_ALLOC_SIZE_MIN - if (x == _PC_ALLOC_SIZE_MIN) - {*r = Mono_Posix_PathConf__PC_ALLOC_SIZE_MIN; return 0;} -#endif /* ndef _PC_ALLOC_SIZE_MIN */ -#ifdef _PC_ASYNC_IO - if (x == _PC_ASYNC_IO) - {*r = Mono_Posix_PathConf__PC_ASYNC_IO; return 0;} -#endif /* ndef _PC_ASYNC_IO */ -#ifdef _PC_CHOWN_RESTRICTED - if (x == _PC_CHOWN_RESTRICTED) - {*r = Mono_Posix_PathConf__PC_CHOWN_RESTRICTED; return 0;} -#endif /* ndef _PC_CHOWN_RESTRICTED */ -#ifdef _PC_FILESIZEBITS - if (x == _PC_FILESIZEBITS) - {*r = Mono_Posix_PathConf__PC_FILESIZEBITS; return 0;} -#endif /* ndef _PC_FILESIZEBITS */ -#ifdef _PC_LINK_MAX - if (x == _PC_LINK_MAX) - {*r = Mono_Posix_PathConf__PC_LINK_MAX; return 0;} -#endif /* ndef _PC_LINK_MAX */ -#ifdef _PC_MAX_CANON - if (x == _PC_MAX_CANON) - {*r = Mono_Posix_PathConf__PC_MAX_CANON; return 0;} -#endif /* ndef _PC_MAX_CANON */ -#ifdef _PC_MAX_INPUT - if (x == _PC_MAX_INPUT) - {*r = Mono_Posix_PathConf__PC_MAX_INPUT; return 0;} -#endif /* ndef _PC_MAX_INPUT */ -#ifdef _PC_NAME_MAX - if (x == _PC_NAME_MAX) - {*r = Mono_Posix_PathConf__PC_NAME_MAX; return 0;} -#endif /* ndef _PC_NAME_MAX */ -#ifdef _PC_NO_TRUNC - if (x == _PC_NO_TRUNC) - {*r = Mono_Posix_PathConf__PC_NO_TRUNC; return 0;} -#endif /* ndef _PC_NO_TRUNC */ -#ifdef _PC_PATH_MAX - if (x == _PC_PATH_MAX) - {*r = Mono_Posix_PathConf__PC_PATH_MAX; return 0;} -#endif /* ndef _PC_PATH_MAX */ -#ifdef _PC_PIPE_BUF - if (x == _PC_PIPE_BUF) - {*r = Mono_Posix_PathConf__PC_PIPE_BUF; return 0;} -#endif /* ndef _PC_PIPE_BUF */ -#ifdef _PC_PRIO_IO - if (x == _PC_PRIO_IO) - {*r = Mono_Posix_PathConf__PC_PRIO_IO; return 0;} -#endif /* ndef _PC_PRIO_IO */ -#ifdef _PC_REC_INCR_XFER_SIZE - if (x == _PC_REC_INCR_XFER_SIZE) - {*r = Mono_Posix_PathConf__PC_REC_INCR_XFER_SIZE; return 0;} -#endif /* ndef _PC_REC_INCR_XFER_SIZE */ -#ifdef _PC_REC_MAX_XFER_SIZE - if (x == _PC_REC_MAX_XFER_SIZE) - {*r = Mono_Posix_PathConf__PC_REC_MAX_XFER_SIZE; return 0;} -#endif /* ndef _PC_REC_MAX_XFER_SIZE */ -#ifdef _PC_REC_MIN_XFER_SIZE - if (x == _PC_REC_MIN_XFER_SIZE) - {*r = Mono_Posix_PathConf__PC_REC_MIN_XFER_SIZE; return 0;} -#endif /* ndef _PC_REC_MIN_XFER_SIZE */ -#ifdef _PC_REC_XFER_ALIGN - if (x == _PC_REC_XFER_ALIGN) - {*r = Mono_Posix_PathConf__PC_REC_XFER_ALIGN; return 0;} -#endif /* ndef _PC_REC_XFER_ALIGN */ -#ifdef _PC_SOCK_MAXBUF - if (x == _PC_SOCK_MAXBUF) - {*r = Mono_Posix_PathConf__PC_SOCK_MAXBUF; return 0;} -#endif /* ndef _PC_SOCK_MAXBUF */ -#ifdef _PC_SYMLINK_MAX - if (x == _PC_SYMLINK_MAX) - {*r = Mono_Posix_PathConf__PC_SYMLINK_MAX; return 0;} -#endif /* ndef _PC_SYMLINK_MAX */ -#ifdef _PC_SYNC_IO - if (x == _PC_SYNC_IO) - {*r = Mono_Posix_PathConf__PC_SYNC_IO; return 0;} -#endif /* ndef _PC_SYNC_IO */ -#ifdef _PC_VDISABLE - if (x == _PC_VDISABLE) - {*r = Mono_Posix_PathConf__PC_VDISABLE; return 0;} -#endif /* ndef _PC_VDISABLE */ - errno = EINVAL; return -1; -} - -int Mono_Posix_FromSysConf (int x, int *r) -{ - *r = 0; - if (x == 0) - return 0; - if (x == Mono_Posix_SysConf__SC_2_CHAR_TERM) -#ifdef _SC_2_CHAR_TERM - {*r = _SC_2_CHAR_TERM; return 0;} -#else /* def _SC_2_CHAR_TERM */ - {errno = EINVAL; return -1;} -#endif /* ndef _SC_2_CHAR_TERM */ - if (x == Mono_Posix_SysConf__SC_2_C_BIND) -#ifdef _SC_2_C_BIND - {*r = _SC_2_C_BIND; return 0;} -#else /* def _SC_2_C_BIND */ - {errno = EINVAL; return -1;} -#endif /* ndef _SC_2_C_BIND */ - if (x == Mono_Posix_SysConf__SC_2_C_DEV) -#ifdef _SC_2_C_DEV - {*r = _SC_2_C_DEV; return 0;} -#else /* def _SC_2_C_DEV */ - {errno = EINVAL; return -1;} -#endif /* ndef _SC_2_C_DEV */ - if (x == Mono_Posix_SysConf__SC_2_C_VERSION) -#ifdef _SC_2_C_VERSION - {*r = _SC_2_C_VERSION; return 0;} -#else /* def _SC_2_C_VERSION */ - {errno = EINVAL; return -1;} -#endif /* ndef _SC_2_C_VERSION */ - if (x == Mono_Posix_SysConf__SC_2_FORT_DEV) -#ifdef _SC_2_FORT_DEV - {*r = _SC_2_FORT_DEV; return 0;} -#else /* def _SC_2_FORT_DEV */ - {errno = EINVAL; return -1;} -#endif /* ndef _SC_2_FORT_DEV */ - if (x == Mono_Posix_SysConf__SC_2_FORT_RUN) -#ifdef _SC_2_FORT_RUN - {*r = _SC_2_FORT_RUN; return 0;} -#else /* def _SC_2_FORT_RUN */ - {errno = EINVAL; return -1;} -#endif /* ndef _SC_2_FORT_RUN */ - if (x == Mono_Posix_SysConf__SC_2_LOCALEDEF) -#ifdef _SC_2_LOCALEDEF - {*r = _SC_2_LOCALEDEF; return 0;} -#else /* def _SC_2_LOCALEDEF */ - {errno = EINVAL; return -1;} -#endif /* ndef _SC_2_LOCALEDEF */ - if (x == Mono_Posix_SysConf__SC_2_PBS) -#ifdef _SC_2_PBS - {*r = _SC_2_PBS; return 0;} -#else /* def _SC_2_PBS */ - {errno = EINVAL; return -1;} -#endif /* ndef _SC_2_PBS */ - if (x == Mono_Posix_SysConf__SC_2_PBS_ACCOUNTING) -#ifdef _SC_2_PBS_ACCOUNTING - {*r = _SC_2_PBS_ACCOUNTING; return 0;} -#else /* def _SC_2_PBS_ACCOUNTING */ - {errno = EINVAL; return -1;} -#endif /* ndef _SC_2_PBS_ACCOUNTING */ - if (x == Mono_Posix_SysConf__SC_2_PBS_CHECKPOINT) -#ifdef _SC_2_PBS_CHECKPOINT - {*r = _SC_2_PBS_CHECKPOINT; return 0;} -#else /* def _SC_2_PBS_CHECKPOINT */ - {errno = EINVAL; return -1;} -#endif /* ndef _SC_2_PBS_CHECKPOINT */ - if (x == Mono_Posix_SysConf__SC_2_PBS_LOCATE) -#ifdef _SC_2_PBS_LOCATE - {*r = _SC_2_PBS_LOCATE; return 0;} -#else /* def _SC_2_PBS_LOCATE */ - {errno = EINVAL; return -1;} -#endif /* ndef _SC_2_PBS_LOCATE */ - if (x == Mono_Posix_SysConf__SC_2_PBS_MESSAGE) -#ifdef _SC_2_PBS_MESSAGE - {*r = _SC_2_PBS_MESSAGE; return 0;} -#else /* def _SC_2_PBS_MESSAGE */ - {errno = EINVAL; return -1;} -#endif /* ndef _SC_2_PBS_MESSAGE */ - if (x == Mono_Posix_SysConf__SC_2_PBS_TRACK) -#ifdef _SC_2_PBS_TRACK - {*r = _SC_2_PBS_TRACK; return 0;} -#else /* def _SC_2_PBS_TRACK */ - {errno = EINVAL; return -1;} -#endif /* ndef _SC_2_PBS_TRACK */ - if (x == Mono_Posix_SysConf__SC_2_SW_DEV) -#ifdef _SC_2_SW_DEV - {*r = _SC_2_SW_DEV; return 0;} -#else /* def _SC_2_SW_DEV */ - {errno = EINVAL; return -1;} -#endif /* ndef _SC_2_SW_DEV */ - if (x == Mono_Posix_SysConf__SC_2_UPE) -#ifdef _SC_2_UPE - {*r = _SC_2_UPE; return 0;} -#else /* def _SC_2_UPE */ - {errno = EINVAL; return -1;} -#endif /* ndef _SC_2_UPE */ - if (x == Mono_Posix_SysConf__SC_2_VERSION) -#ifdef _SC_2_VERSION - {*r = _SC_2_VERSION; return 0;} -#else /* def _SC_2_VERSION */ - {errno = EINVAL; return -1;} -#endif /* ndef _SC_2_VERSION */ - if (x == Mono_Posix_SysConf__SC_ADVISORY_INFO) -#ifdef _SC_ADVISORY_INFO - {*r = _SC_ADVISORY_INFO; return 0;} -#else /* def _SC_ADVISORY_INFO */ - {errno = EINVAL; return -1;} -#endif /* ndef _SC_ADVISORY_INFO */ - if (x == Mono_Posix_SysConf__SC_AIO_LISTIO_MAX) -#ifdef _SC_AIO_LISTIO_MAX - {*r = _SC_AIO_LISTIO_MAX; return 0;} -#else /* def _SC_AIO_LISTIO_MAX */ - {errno = EINVAL; return -1;} -#endif /* ndef _SC_AIO_LISTIO_MAX */ - if (x == Mono_Posix_SysConf__SC_AIO_MAX) -#ifdef _SC_AIO_MAX - {*r = _SC_AIO_MAX; return 0;} -#else /* def _SC_AIO_MAX */ - {errno = EINVAL; return -1;} -#endif /* ndef _SC_AIO_MAX */ - if (x == Mono_Posix_SysConf__SC_AIO_PRIO_DELTA_MAX) -#ifdef _SC_AIO_PRIO_DELTA_MAX - {*r = _SC_AIO_PRIO_DELTA_MAX; return 0;} -#else /* def _SC_AIO_PRIO_DELTA_MAX */ - {errno = EINVAL; return -1;} -#endif /* ndef _SC_AIO_PRIO_DELTA_MAX */ - if (x == Mono_Posix_SysConf__SC_ARG_MAX) -#ifdef _SC_ARG_MAX - {*r = _SC_ARG_MAX; return 0;} -#else /* def _SC_ARG_MAX */ - {errno = EINVAL; return -1;} -#endif /* ndef _SC_ARG_MAX */ - if (x == Mono_Posix_SysConf__SC_ASYNCHRONOUS_IO) -#ifdef _SC_ASYNCHRONOUS_IO - {*r = _SC_ASYNCHRONOUS_IO; return 0;} -#else /* def _SC_ASYNCHRONOUS_IO */ - {errno = EINVAL; return -1;} -#endif /* ndef _SC_ASYNCHRONOUS_IO */ - if (x == Mono_Posix_SysConf__SC_ATEXIT_MAX) -#ifdef _SC_ATEXIT_MAX - {*r = _SC_ATEXIT_MAX; return 0;} -#else /* def _SC_ATEXIT_MAX */ - {errno = EINVAL; return -1;} -#endif /* ndef _SC_ATEXIT_MAX */ - if (x == Mono_Posix_SysConf__SC_AVPHYS_PAGES) -#ifdef _SC_AVPHYS_PAGES - {*r = _SC_AVPHYS_PAGES; return 0;} -#else /* def _SC_AVPHYS_PAGES */ - {errno = EINVAL; return -1;} -#endif /* ndef _SC_AVPHYS_PAGES */ - if (x == Mono_Posix_SysConf__SC_BARRIERS) -#ifdef _SC_BARRIERS - {*r = _SC_BARRIERS; return 0;} -#else /* def _SC_BARRIERS */ - {errno = EINVAL; return -1;} -#endif /* ndef _SC_BARRIERS */ - if (x == Mono_Posix_SysConf__SC_BASE) -#ifdef _SC_BASE - {*r = _SC_BASE; return 0;} -#else /* def _SC_BASE */ - {errno = EINVAL; return -1;} -#endif /* ndef _SC_BASE */ - if (x == Mono_Posix_SysConf__SC_BC_BASE_MAX) -#ifdef _SC_BC_BASE_MAX - {*r = _SC_BC_BASE_MAX; return 0;} -#else /* def _SC_BC_BASE_MAX */ - {errno = EINVAL; return -1;} -#endif /* ndef _SC_BC_BASE_MAX */ - if (x == Mono_Posix_SysConf__SC_BC_DIM_MAX) -#ifdef _SC_BC_DIM_MAX - {*r = _SC_BC_DIM_MAX; return 0;} -#else /* def _SC_BC_DIM_MAX */ - {errno = EINVAL; return -1;} -#endif /* ndef _SC_BC_DIM_MAX */ - if (x == Mono_Posix_SysConf__SC_BC_SCALE_MAX) -#ifdef _SC_BC_SCALE_MAX - {*r = _SC_BC_SCALE_MAX; return 0;} -#else /* def _SC_BC_SCALE_MAX */ - {errno = EINVAL; return -1;} -#endif /* ndef _SC_BC_SCALE_MAX */ - if (x == Mono_Posix_SysConf__SC_BC_STRING_MAX) -#ifdef _SC_BC_STRING_MAX - {*r = _SC_BC_STRING_MAX; return 0;} -#else /* def _SC_BC_STRING_MAX */ - {errno = EINVAL; return -1;} -#endif /* ndef _SC_BC_STRING_MAX */ - if (x == Mono_Posix_SysConf__SC_CHARCLASS_NAME_MAX) -#ifdef _SC_CHARCLASS_NAME_MAX - {*r = _SC_CHARCLASS_NAME_MAX; return 0;} -#else /* def _SC_CHARCLASS_NAME_MAX */ - {errno = EINVAL; return -1;} -#endif /* ndef _SC_CHARCLASS_NAME_MAX */ - if (x == Mono_Posix_SysConf__SC_CHAR_BIT) -#ifdef _SC_CHAR_BIT - {*r = _SC_CHAR_BIT; return 0;} -#else /* def _SC_CHAR_BIT */ - {errno = EINVAL; return -1;} -#endif /* ndef _SC_CHAR_BIT */ - if (x == Mono_Posix_SysConf__SC_CHAR_MAX) -#ifdef _SC_CHAR_MAX - {*r = _SC_CHAR_MAX; return 0;} -#else /* def _SC_CHAR_MAX */ - {errno = EINVAL; return -1;} -#endif /* ndef _SC_CHAR_MAX */ - if (x == Mono_Posix_SysConf__SC_CHAR_MIN) -#ifdef _SC_CHAR_MIN - {*r = _SC_CHAR_MIN; return 0;} -#else /* def _SC_CHAR_MIN */ - {errno = EINVAL; return -1;} -#endif /* ndef _SC_CHAR_MIN */ - if (x == Mono_Posix_SysConf__SC_CHILD_MAX) -#ifdef _SC_CHILD_MAX - {*r = _SC_CHILD_MAX; return 0;} -#else /* def _SC_CHILD_MAX */ - {errno = EINVAL; return -1;} -#endif /* ndef _SC_CHILD_MAX */ - if (x == Mono_Posix_SysConf__SC_CLK_TCK) -#ifdef _SC_CLK_TCK - {*r = _SC_CLK_TCK; return 0;} -#else /* def _SC_CLK_TCK */ - {errno = EINVAL; return -1;} -#endif /* ndef _SC_CLK_TCK */ - if (x == Mono_Posix_SysConf__SC_CLOCK_SELECTION) -#ifdef _SC_CLOCK_SELECTION - {*r = _SC_CLOCK_SELECTION; return 0;} -#else /* def _SC_CLOCK_SELECTION */ - {errno = EINVAL; return -1;} -#endif /* ndef _SC_CLOCK_SELECTION */ - if (x == Mono_Posix_SysConf__SC_COLL_WEIGHTS_MAX) -#ifdef _SC_COLL_WEIGHTS_MAX - {*r = _SC_COLL_WEIGHTS_MAX; return 0;} -#else /* def _SC_COLL_WEIGHTS_MAX */ - {errno = EINVAL; return -1;} -#endif /* ndef _SC_COLL_WEIGHTS_MAX */ - if (x == Mono_Posix_SysConf__SC_CPUTIME) -#ifdef _SC_CPUTIME - {*r = _SC_CPUTIME; return 0;} -#else /* def _SC_CPUTIME */ - {errno = EINVAL; return -1;} -#endif /* ndef _SC_CPUTIME */ - if (x == Mono_Posix_SysConf__SC_C_LANG_SUPPORT) -#ifdef _SC_C_LANG_SUPPORT - {*r = _SC_C_LANG_SUPPORT; return 0;} -#else /* def _SC_C_LANG_SUPPORT */ - {errno = EINVAL; return -1;} -#endif /* ndef _SC_C_LANG_SUPPORT */ - if (x == Mono_Posix_SysConf__SC_C_LANG_SUPPORT_R) -#ifdef _SC_C_LANG_SUPPORT_R - {*r = _SC_C_LANG_SUPPORT_R; return 0;} -#else /* def _SC_C_LANG_SUPPORT_R */ - {errno = EINVAL; return -1;} -#endif /* ndef _SC_C_LANG_SUPPORT_R */ - if (x == Mono_Posix_SysConf__SC_DELAYTIMER_MAX) -#ifdef _SC_DELAYTIMER_MAX - {*r = _SC_DELAYTIMER_MAX; return 0;} -#else /* def _SC_DELAYTIMER_MAX */ - {errno = EINVAL; return -1;} -#endif /* ndef _SC_DELAYTIMER_MAX */ - if (x == Mono_Posix_SysConf__SC_DEVICE_IO) -#ifdef _SC_DEVICE_IO - {*r = _SC_DEVICE_IO; return 0;} -#else /* def _SC_DEVICE_IO */ - {errno = EINVAL; return -1;} -#endif /* ndef _SC_DEVICE_IO */ - if (x == Mono_Posix_SysConf__SC_DEVICE_SPECIFIC) -#ifdef _SC_DEVICE_SPECIFIC - {*r = _SC_DEVICE_SPECIFIC; return 0;} -#else /* def _SC_DEVICE_SPECIFIC */ - {errno = EINVAL; return -1;} -#endif /* ndef _SC_DEVICE_SPECIFIC */ - if (x == Mono_Posix_SysConf__SC_DEVICE_SPECIFIC_R) -#ifdef _SC_DEVICE_SPECIFIC_R - {*r = _SC_DEVICE_SPECIFIC_R; return 0;} -#else /* def _SC_DEVICE_SPECIFIC_R */ - {errno = EINVAL; return -1;} -#endif /* ndef _SC_DEVICE_SPECIFIC_R */ - if (x == Mono_Posix_SysConf__SC_EQUIV_CLASS_MAX) -#ifdef _SC_EQUIV_CLASS_MAX - {*r = _SC_EQUIV_CLASS_MAX; return 0;} -#else /* def _SC_EQUIV_CLASS_MAX */ - {errno = EINVAL; return -1;} -#endif /* ndef _SC_EQUIV_CLASS_MAX */ - if (x == Mono_Posix_SysConf__SC_EXPR_NEST_MAX) -#ifdef _SC_EXPR_NEST_MAX - {*r = _SC_EXPR_NEST_MAX; return 0;} -#else /* def _SC_EXPR_NEST_MAX */ - {errno = EINVAL; return -1;} -#endif /* ndef _SC_EXPR_NEST_MAX */ - if (x == Mono_Posix_SysConf__SC_FD_MGMT) -#ifdef _SC_FD_MGMT - {*r = _SC_FD_MGMT; return 0;} -#else /* def _SC_FD_MGMT */ - {errno = EINVAL; return -1;} -#endif /* ndef _SC_FD_MGMT */ - if (x == Mono_Posix_SysConf__SC_FIFO) -#ifdef _SC_FIFO - {*r = _SC_FIFO; return 0;} -#else /* def _SC_FIFO */ - {errno = EINVAL; return -1;} -#endif /* ndef _SC_FIFO */ - if (x == Mono_Posix_SysConf__SC_FILE_ATTRIBUTES) -#ifdef _SC_FILE_ATTRIBUTES - {*r = _SC_FILE_ATTRIBUTES; return 0;} -#else /* def _SC_FILE_ATTRIBUTES */ - {errno = EINVAL; return -1;} -#endif /* ndef _SC_FILE_ATTRIBUTES */ - if (x == Mono_Posix_SysConf__SC_FILE_LOCKING) -#ifdef _SC_FILE_LOCKING - {*r = _SC_FILE_LOCKING; return 0;} -#else /* def _SC_FILE_LOCKING */ - {errno = EINVAL; return -1;} -#endif /* ndef _SC_FILE_LOCKING */ - if (x == Mono_Posix_SysConf__SC_FILE_SYSTEM) -#ifdef _SC_FILE_SYSTEM - {*r = _SC_FILE_SYSTEM; return 0;} -#else /* def _SC_FILE_SYSTEM */ - {errno = EINVAL; return -1;} -#endif /* ndef _SC_FILE_SYSTEM */ - if (x == Mono_Posix_SysConf__SC_FSYNC) -#ifdef _SC_FSYNC - {*r = _SC_FSYNC; return 0;} -#else /* def _SC_FSYNC */ - {errno = EINVAL; return -1;} -#endif /* ndef _SC_FSYNC */ - if (x == Mono_Posix_SysConf__SC_GETGR_R_SIZE_MAX) -#ifdef _SC_GETGR_R_SIZE_MAX - {*r = _SC_GETGR_R_SIZE_MAX; return 0;} -#else /* def _SC_GETGR_R_SIZE_MAX */ - {errno = EINVAL; return -1;} -#endif /* ndef _SC_GETGR_R_SIZE_MAX */ - if (x == Mono_Posix_SysConf__SC_GETPW_R_SIZE_MAX) -#ifdef _SC_GETPW_R_SIZE_MAX - {*r = _SC_GETPW_R_SIZE_MAX; return 0;} -#else /* def _SC_GETPW_R_SIZE_MAX */ - {errno = EINVAL; return -1;} -#endif /* ndef _SC_GETPW_R_SIZE_MAX */ - if (x == Mono_Posix_SysConf__SC_HOST_NAME_MAX) -#ifdef _SC_HOST_NAME_MAX - {*r = _SC_HOST_NAME_MAX; return 0;} -#else /* def _SC_HOST_NAME_MAX */ - {errno = EINVAL; return -1;} -#endif /* ndef _SC_HOST_NAME_MAX */ - if (x == Mono_Posix_SysConf__SC_INT_MAX) -#ifdef _SC_INT_MAX - {*r = _SC_INT_MAX; return 0;} -#else /* def _SC_INT_MAX */ - {errno = EINVAL; return -1;} -#endif /* ndef _SC_INT_MAX */ - if (x == Mono_Posix_SysConf__SC_INT_MIN) -#ifdef _SC_INT_MIN - {*r = _SC_INT_MIN; return 0;} -#else /* def _SC_INT_MIN */ - {errno = EINVAL; return -1;} -#endif /* ndef _SC_INT_MIN */ - if (x == Mono_Posix_SysConf__SC_IOV_MAX) -#ifdef _SC_IOV_MAX - {*r = _SC_IOV_MAX; return 0;} -#else /* def _SC_IOV_MAX */ - {errno = EINVAL; return -1;} -#endif /* ndef _SC_IOV_MAX */ - if (x == Mono_Posix_SysConf__SC_JOB_CONTROL) -#ifdef _SC_JOB_CONTROL - {*r = _SC_JOB_CONTROL; return 0;} -#else /* def _SC_JOB_CONTROL */ - {errno = EINVAL; return -1;} -#endif /* ndef _SC_JOB_CONTROL */ - if (x == Mono_Posix_SysConf__SC_LEVEL1_DCACHE_ASSOC) -#ifdef _SC_LEVEL1_DCACHE_ASSOC - {*r = _SC_LEVEL1_DCACHE_ASSOC; return 0;} -#else /* def _SC_LEVEL1_DCACHE_ASSOC */ - {errno = EINVAL; return -1;} -#endif /* ndef _SC_LEVEL1_DCACHE_ASSOC */ - if (x == Mono_Posix_SysConf__SC_LEVEL1_DCACHE_LINESIZE) -#ifdef _SC_LEVEL1_DCACHE_LINESIZE - {*r = _SC_LEVEL1_DCACHE_LINESIZE; return 0;} -#else /* def _SC_LEVEL1_DCACHE_LINESIZE */ - {errno = EINVAL; return -1;} -#endif /* ndef _SC_LEVEL1_DCACHE_LINESIZE */ - if (x == Mono_Posix_SysConf__SC_LEVEL1_DCACHE_SIZE) -#ifdef _SC_LEVEL1_DCACHE_SIZE - {*r = _SC_LEVEL1_DCACHE_SIZE; return 0;} -#else /* def _SC_LEVEL1_DCACHE_SIZE */ - {errno = EINVAL; return -1;} -#endif /* ndef _SC_LEVEL1_DCACHE_SIZE */ - if (x == Mono_Posix_SysConf__SC_LEVEL1_ICACHE_ASSOC) -#ifdef _SC_LEVEL1_ICACHE_ASSOC - {*r = _SC_LEVEL1_ICACHE_ASSOC; return 0;} -#else /* def _SC_LEVEL1_ICACHE_ASSOC */ - {errno = EINVAL; return -1;} -#endif /* ndef _SC_LEVEL1_ICACHE_ASSOC */ - if (x == Mono_Posix_SysConf__SC_LEVEL1_ICACHE_LINESIZE) -#ifdef _SC_LEVEL1_ICACHE_LINESIZE - {*r = _SC_LEVEL1_ICACHE_LINESIZE; return 0;} -#else /* def _SC_LEVEL1_ICACHE_LINESIZE */ - {errno = EINVAL; return -1;} -#endif /* ndef _SC_LEVEL1_ICACHE_LINESIZE */ - if (x == Mono_Posix_SysConf__SC_LEVEL1_ICACHE_SIZE) -#ifdef _SC_LEVEL1_ICACHE_SIZE - {*r = _SC_LEVEL1_ICACHE_SIZE; return 0;} -#else /* def _SC_LEVEL1_ICACHE_SIZE */ - {errno = EINVAL; return -1;} -#endif /* ndef _SC_LEVEL1_ICACHE_SIZE */ - if (x == Mono_Posix_SysConf__SC_LEVEL2_CACHE_ASSOC) -#ifdef _SC_LEVEL2_CACHE_ASSOC - {*r = _SC_LEVEL2_CACHE_ASSOC; return 0;} -#else /* def _SC_LEVEL2_CACHE_ASSOC */ - {errno = EINVAL; return -1;} -#endif /* ndef _SC_LEVEL2_CACHE_ASSOC */ - if (x == Mono_Posix_SysConf__SC_LEVEL2_CACHE_LINESIZE) -#ifdef _SC_LEVEL2_CACHE_LINESIZE - {*r = _SC_LEVEL2_CACHE_LINESIZE; return 0;} -#else /* def _SC_LEVEL2_CACHE_LINESIZE */ - {errno = EINVAL; return -1;} -#endif /* ndef _SC_LEVEL2_CACHE_LINESIZE */ - if (x == Mono_Posix_SysConf__SC_LEVEL2_CACHE_SIZE) -#ifdef _SC_LEVEL2_CACHE_SIZE - {*r = _SC_LEVEL2_CACHE_SIZE; return 0;} -#else /* def _SC_LEVEL2_CACHE_SIZE */ - {errno = EINVAL; return -1;} -#endif /* ndef _SC_LEVEL2_CACHE_SIZE */ - if (x == Mono_Posix_SysConf__SC_LEVEL3_CACHE_ASSOC) -#ifdef _SC_LEVEL3_CACHE_ASSOC - {*r = _SC_LEVEL3_CACHE_ASSOC; return 0;} -#else /* def _SC_LEVEL3_CACHE_ASSOC */ - {errno = EINVAL; return -1;} -#endif /* ndef _SC_LEVEL3_CACHE_ASSOC */ - if (x == Mono_Posix_SysConf__SC_LEVEL3_CACHE_LINESIZE) -#ifdef _SC_LEVEL3_CACHE_LINESIZE - {*r = _SC_LEVEL3_CACHE_LINESIZE; return 0;} -#else /* def _SC_LEVEL3_CACHE_LINESIZE */ - {errno = EINVAL; return -1;} -#endif /* ndef _SC_LEVEL3_CACHE_LINESIZE */ - if (x == Mono_Posix_SysConf__SC_LEVEL3_CACHE_SIZE) -#ifdef _SC_LEVEL3_CACHE_SIZE - {*r = _SC_LEVEL3_CACHE_SIZE; return 0;} -#else /* def _SC_LEVEL3_CACHE_SIZE */ - {errno = EINVAL; return -1;} -#endif /* ndef _SC_LEVEL3_CACHE_SIZE */ - if (x == Mono_Posix_SysConf__SC_LEVEL4_CACHE_ASSOC) -#ifdef _SC_LEVEL4_CACHE_ASSOC - {*r = _SC_LEVEL4_CACHE_ASSOC; return 0;} -#else /* def _SC_LEVEL4_CACHE_ASSOC */ - {errno = EINVAL; return -1;} -#endif /* ndef _SC_LEVEL4_CACHE_ASSOC */ - if (x == Mono_Posix_SysConf__SC_LEVEL4_CACHE_LINESIZE) -#ifdef _SC_LEVEL4_CACHE_LINESIZE - {*r = _SC_LEVEL4_CACHE_LINESIZE; return 0;} -#else /* def _SC_LEVEL4_CACHE_LINESIZE */ - {errno = EINVAL; return -1;} -#endif /* ndef _SC_LEVEL4_CACHE_LINESIZE */ - if (x == Mono_Posix_SysConf__SC_LEVEL4_CACHE_SIZE) -#ifdef _SC_LEVEL4_CACHE_SIZE - {*r = _SC_LEVEL4_CACHE_SIZE; return 0;} -#else /* def _SC_LEVEL4_CACHE_SIZE */ - {errno = EINVAL; return -1;} -#endif /* ndef _SC_LEVEL4_CACHE_SIZE */ - if (x == Mono_Posix_SysConf__SC_LINE_MAX) -#ifdef _SC_LINE_MAX - {*r = _SC_LINE_MAX; return 0;} -#else /* def _SC_LINE_MAX */ - {errno = EINVAL; return -1;} -#endif /* ndef _SC_LINE_MAX */ - if (x == Mono_Posix_SysConf__SC_LOGIN_NAME_MAX) -#ifdef _SC_LOGIN_NAME_MAX - {*r = _SC_LOGIN_NAME_MAX; return 0;} -#else /* def _SC_LOGIN_NAME_MAX */ - {errno = EINVAL; return -1;} -#endif /* ndef _SC_LOGIN_NAME_MAX */ - if (x == Mono_Posix_SysConf__SC_LONG_BIT) -#ifdef _SC_LONG_BIT - {*r = _SC_LONG_BIT; return 0;} -#else /* def _SC_LONG_BIT */ - {errno = EINVAL; return -1;} -#endif /* ndef _SC_LONG_BIT */ - if (x == Mono_Posix_SysConf__SC_MAPPED_FILES) -#ifdef _SC_MAPPED_FILES - {*r = _SC_MAPPED_FILES; return 0;} -#else /* def _SC_MAPPED_FILES */ - {errno = EINVAL; return -1;} -#endif /* ndef _SC_MAPPED_FILES */ - if (x == Mono_Posix_SysConf__SC_MB_LEN_MAX) -#ifdef _SC_MB_LEN_MAX - {*r = _SC_MB_LEN_MAX; return 0;} -#else /* def _SC_MB_LEN_MAX */ - {errno = EINVAL; return -1;} -#endif /* ndef _SC_MB_LEN_MAX */ - if (x == Mono_Posix_SysConf__SC_MEMLOCK) -#ifdef _SC_MEMLOCK - {*r = _SC_MEMLOCK; return 0;} -#else /* def _SC_MEMLOCK */ - {errno = EINVAL; return -1;} -#endif /* ndef _SC_MEMLOCK */ - if (x == Mono_Posix_SysConf__SC_MEMLOCK_RANGE) -#ifdef _SC_MEMLOCK_RANGE - {*r = _SC_MEMLOCK_RANGE; return 0;} -#else /* def _SC_MEMLOCK_RANGE */ - {errno = EINVAL; return -1;} -#endif /* ndef _SC_MEMLOCK_RANGE */ - if (x == Mono_Posix_SysConf__SC_MEMORY_PROTECTION) -#ifdef _SC_MEMORY_PROTECTION - {*r = _SC_MEMORY_PROTECTION; return 0;} -#else /* def _SC_MEMORY_PROTECTION */ - {errno = EINVAL; return -1;} -#endif /* ndef _SC_MEMORY_PROTECTION */ - if (x == Mono_Posix_SysConf__SC_MESSAGE_PASSING) -#ifdef _SC_MESSAGE_PASSING - {*r = _SC_MESSAGE_PASSING; return 0;} -#else /* def _SC_MESSAGE_PASSING */ - {errno = EINVAL; return -1;} -#endif /* ndef _SC_MESSAGE_PASSING */ - if (x == Mono_Posix_SysConf__SC_MONOTONIC_CLOCK) -#ifdef _SC_MONOTONIC_CLOCK - {*r = _SC_MONOTONIC_CLOCK; return 0;} -#else /* def _SC_MONOTONIC_CLOCK */ - {errno = EINVAL; return -1;} -#endif /* ndef _SC_MONOTONIC_CLOCK */ - if (x == Mono_Posix_SysConf__SC_MQ_OPEN_MAX) -#ifdef _SC_MQ_OPEN_MAX - {*r = _SC_MQ_OPEN_MAX; return 0;} -#else /* def _SC_MQ_OPEN_MAX */ - {errno = EINVAL; return -1;} -#endif /* ndef _SC_MQ_OPEN_MAX */ - if (x == Mono_Posix_SysConf__SC_MQ_PRIO_MAX) -#ifdef _SC_MQ_PRIO_MAX - {*r = _SC_MQ_PRIO_MAX; return 0;} -#else /* def _SC_MQ_PRIO_MAX */ - {errno = EINVAL; return -1;} -#endif /* ndef _SC_MQ_PRIO_MAX */ - if (x == Mono_Posix_SysConf__SC_MULTI_PROCESS) -#ifdef _SC_MULTI_PROCESS - {*r = _SC_MULTI_PROCESS; return 0;} -#else /* def _SC_MULTI_PROCESS */ - {errno = EINVAL; return -1;} -#endif /* ndef _SC_MULTI_PROCESS */ - if (x == Mono_Posix_SysConf__SC_NETWORKING) -#ifdef _SC_NETWORKING - {*r = _SC_NETWORKING; return 0;} -#else /* def _SC_NETWORKING */ - {errno = EINVAL; return -1;} -#endif /* ndef _SC_NETWORKING */ - if (x == Mono_Posix_SysConf__SC_NGROUPS_MAX) -#ifdef _SC_NGROUPS_MAX - {*r = _SC_NGROUPS_MAX; return 0;} -#else /* def _SC_NGROUPS_MAX */ - {errno = EINVAL; return -1;} -#endif /* ndef _SC_NGROUPS_MAX */ - if (x == Mono_Posix_SysConf__SC_NL_ARGMAX) -#ifdef _SC_NL_ARGMAX - {*r = _SC_NL_ARGMAX; return 0;} -#else /* def _SC_NL_ARGMAX */ - {errno = EINVAL; return -1;} -#endif /* ndef _SC_NL_ARGMAX */ - if (x == Mono_Posix_SysConf__SC_NL_LANGMAX) -#ifdef _SC_NL_LANGMAX - {*r = _SC_NL_LANGMAX; return 0;} -#else /* def _SC_NL_LANGMAX */ - {errno = EINVAL; return -1;} -#endif /* ndef _SC_NL_LANGMAX */ - if (x == Mono_Posix_SysConf__SC_NL_MSGMAX) -#ifdef _SC_NL_MSGMAX - {*r = _SC_NL_MSGMAX; return 0;} -#else /* def _SC_NL_MSGMAX */ - {errno = EINVAL; return -1;} -#endif /* ndef _SC_NL_MSGMAX */ - if (x == Mono_Posix_SysConf__SC_NL_NMAX) -#ifdef _SC_NL_NMAX - {*r = _SC_NL_NMAX; return 0;} -#else /* def _SC_NL_NMAX */ - {errno = EINVAL; return -1;} -#endif /* ndef _SC_NL_NMAX */ - if (x == Mono_Posix_SysConf__SC_NL_SETMAX) -#ifdef _SC_NL_SETMAX - {*r = _SC_NL_SETMAX; return 0;} -#else /* def _SC_NL_SETMAX */ - {errno = EINVAL; return -1;} -#endif /* ndef _SC_NL_SETMAX */ - if (x == Mono_Posix_SysConf__SC_NL_TEXTMAX) -#ifdef _SC_NL_TEXTMAX - {*r = _SC_NL_TEXTMAX; return 0;} -#else /* def _SC_NL_TEXTMAX */ - {errno = EINVAL; return -1;} -#endif /* ndef _SC_NL_TEXTMAX */ - if (x == Mono_Posix_SysConf__SC_NPROCESSORS_CONF) -#ifdef _SC_NPROCESSORS_CONF - {*r = _SC_NPROCESSORS_CONF; return 0;} -#else /* def _SC_NPROCESSORS_CONF */ - {errno = EINVAL; return -1;} -#endif /* ndef _SC_NPROCESSORS_CONF */ - if (x == Mono_Posix_SysConf__SC_NPROCESSORS_ONLN) -#ifdef _SC_NPROCESSORS_ONLN - {*r = _SC_NPROCESSORS_ONLN; return 0;} -#else /* def _SC_NPROCESSORS_ONLN */ - {errno = EINVAL; return -1;} -#endif /* ndef _SC_NPROCESSORS_ONLN */ - if (x == Mono_Posix_SysConf__SC_NZERO) -#ifdef _SC_NZERO - {*r = _SC_NZERO; return 0;} -#else /* def _SC_NZERO */ - {errno = EINVAL; return -1;} -#endif /* ndef _SC_NZERO */ - if (x == Mono_Posix_SysConf__SC_OPEN_MAX) -#ifdef _SC_OPEN_MAX - {*r = _SC_OPEN_MAX; return 0;} -#else /* def _SC_OPEN_MAX */ - {errno = EINVAL; return -1;} -#endif /* ndef _SC_OPEN_MAX */ - if (x == Mono_Posix_SysConf__SC_PAGESIZE) -#ifdef _SC_PAGESIZE - {*r = _SC_PAGESIZE; return 0;} -#else /* def _SC_PAGESIZE */ - {errno = EINVAL; return -1;} -#endif /* ndef _SC_PAGESIZE */ - if (x == Mono_Posix_SysConf__SC_PASS_MAX) -#ifdef _SC_PASS_MAX - {*r = _SC_PASS_MAX; return 0;} -#else /* def _SC_PASS_MAX */ - {errno = EINVAL; return -1;} -#endif /* ndef _SC_PASS_MAX */ - if (x == Mono_Posix_SysConf__SC_PHYS_PAGES) -#ifdef _SC_PHYS_PAGES - {*r = _SC_PHYS_PAGES; return 0;} -#else /* def _SC_PHYS_PAGES */ - {errno = EINVAL; return -1;} -#endif /* ndef _SC_PHYS_PAGES */ - if (x == Mono_Posix_SysConf__SC_PII) -#ifdef _SC_PII - {*r = _SC_PII; return 0;} -#else /* def _SC_PII */ - {errno = EINVAL; return -1;} -#endif /* ndef _SC_PII */ - if (x == Mono_Posix_SysConf__SC_PII_INTERNET) -#ifdef _SC_PII_INTERNET - {*r = _SC_PII_INTERNET; return 0;} -#else /* def _SC_PII_INTERNET */ - {errno = EINVAL; return -1;} -#endif /* ndef _SC_PII_INTERNET */ - if (x == Mono_Posix_SysConf__SC_PII_INTERNET_DGRAM) -#ifdef _SC_PII_INTERNET_DGRAM - {*r = _SC_PII_INTERNET_DGRAM; return 0;} -#else /* def _SC_PII_INTERNET_DGRAM */ - {errno = EINVAL; return -1;} -#endif /* ndef _SC_PII_INTERNET_DGRAM */ - if (x == Mono_Posix_SysConf__SC_PII_INTERNET_STREAM) -#ifdef _SC_PII_INTERNET_STREAM - {*r = _SC_PII_INTERNET_STREAM; return 0;} -#else /* def _SC_PII_INTERNET_STREAM */ - {errno = EINVAL; return -1;} -#endif /* ndef _SC_PII_INTERNET_STREAM */ - if (x == Mono_Posix_SysConf__SC_PII_OSI) -#ifdef _SC_PII_OSI - {*r = _SC_PII_OSI; return 0;} -#else /* def _SC_PII_OSI */ - {errno = EINVAL; return -1;} -#endif /* ndef _SC_PII_OSI */ - if (x == Mono_Posix_SysConf__SC_PII_OSI_CLTS) -#ifdef _SC_PII_OSI_CLTS - {*r = _SC_PII_OSI_CLTS; return 0;} -#else /* def _SC_PII_OSI_CLTS */ - {errno = EINVAL; return -1;} -#endif /* ndef _SC_PII_OSI_CLTS */ - if (x == Mono_Posix_SysConf__SC_PII_OSI_COTS) -#ifdef _SC_PII_OSI_COTS - {*r = _SC_PII_OSI_COTS; return 0;} -#else /* def _SC_PII_OSI_COTS */ - {errno = EINVAL; return -1;} -#endif /* ndef _SC_PII_OSI_COTS */ - if (x == Mono_Posix_SysConf__SC_PII_OSI_M) -#ifdef _SC_PII_OSI_M - {*r = _SC_PII_OSI_M; return 0;} -#else /* def _SC_PII_OSI_M */ - {errno = EINVAL; return -1;} -#endif /* ndef _SC_PII_OSI_M */ - if (x == Mono_Posix_SysConf__SC_PII_SOCKET) -#ifdef _SC_PII_SOCKET - {*r = _SC_PII_SOCKET; return 0;} -#else /* def _SC_PII_SOCKET */ - {errno = EINVAL; return -1;} -#endif /* ndef _SC_PII_SOCKET */ - if (x == Mono_Posix_SysConf__SC_PII_XTI) -#ifdef _SC_PII_XTI - {*r = _SC_PII_XTI; return 0;} -#else /* def _