Update mappings after latest changes to Mono.Posix

	New mappings created for the epoll code.

diff --git a/mcs/class/Mono.Posix/Mono.Unix.Native/NativeConvert.generated.cs b/mcs/class/Mono.Posix/Mono.Unix.Native/NativeConvert.generated.cs
index 960b5c21032987e77002bc81aedc426db818a14b..be846a892c168fe195d48e0fc1ed44e677afef18 100644 (file)
--- a/mcs/class/Mono.Posix/Mono.Unix.Native/NativeConvert.generated.cs
+++ b/mcs/class/Mono.Posix/Mono.Unix.Native/NativeConvert.generated.cs
@@ -118,6 +118,70 @@ namespace Mono.Unix.Native {
                        return rval;
                }
 
+               [DllImport (LIB, EntryPoint="Mono_Posix_FromEpollEvents")]
+               private static extern int FromEpollEvents (EpollEvents value, out UInt32 rval);
+
+               public static bool TryFromEpollEvents (EpollEvents value, out UInt32 rval)
+               {
+                       return FromEpollEvents (value, out rval) == 0;
+               }
+
+               public static UInt32 FromEpollEvents (EpollEvents value)
+               {
+                       UInt32 rval;
+                       if (FromEpollEvents (value, out rval) == -1)
+                               ThrowArgumentException (value);
+                       return rval;
+               }
+
+               [DllImport (LIB, EntryPoint="Mono_Posix_ToEpollEvents")]
+               private static extern int ToEpollEvents (UInt32 value, out EpollEvents rval);
+
+               public static bool TryToEpollEvents (UInt32 value, out EpollEvents rval)
+               {
+                       return ToEpollEvents (value, out rval) == 0;
+               }
+
+               public static EpollEvents ToEpollEvents (UInt32 value)
+               {
+                       EpollEvents rval;
+                       if (ToEpollEvents (value, out rval) == -1)
+                               ThrowArgumentException (value);
+                       return rval;
+               }
+
+               [DllImport (LIB, EntryPoint="Mono_Posix_FromEpollFlags")]
+               private static extern int FromEpollFlags (EpollFlags value, out Int32 rval);
+
+               public static bool TryFromEpollFlags (EpollFlags value, out Int32 rval)
+               {
+                       return FromEpollFlags (value, out rval) == 0;
+               }
+
+               public static Int32 FromEpollFlags (EpollFlags value)
+               {
+                       Int32 rval;
+                       if (FromEpollFlags (value, out rval) == -1)
+                               ThrowArgumentException (value);
+                       return rval;
+               }
+
+               [DllImport (LIB, EntryPoint="Mono_Posix_ToEpollFlags")]
+               private static extern int ToEpollFlags (Int32 value, out EpollFlags rval);
+
+               public static bool TryToEpollFlags (Int32 value, out EpollFlags rval)
+               {
+                       return ToEpollFlags (value, out rval) == 0;
+               }
+
+               public static EpollFlags ToEpollFlags (Int32 value)
+               {
+                       EpollFlags rval;
+                       if (ToEpollFlags (value, out rval) == -1)
+                               ThrowArgumentException (value);
+                       return rval;
+               }
+
                [DllImport (LIB, EntryPoint="Mono_Posix_FromErrno")]
                private static extern int FromErrno (Errno value, out Int32 rval);
 

diff --git a/support/map.c b/support/map.c
index 0fc5255640b4655b3d5928221ed767ecb24520fa..cb653bcda9a81e0c8f09b4e26c3da802b1c4ab96 100644 (file)
--- a/support/map.c
+++ b/support/map.c
@@ -834,6 +834,188 @@ int Mono_Posix_ToDirectoryNotifyFlags (int x, int *r)
        return 0;
 }
 
+int Mono_Posix_FromEpollEvents (unsigned int x, unsigned int *r)
+{
+       *r = 0;
+       if ((x & Mono_Posix_EpollEvents_EPOLLERR) == Mono_Posix_EpollEvents_EPOLLERR)
+#ifdef EPOLLERR
+               *r |= EPOLLERR;
+#else /* def EPOLLERR */
+               {errno = EINVAL; return -1;}
+#endif /* ndef EPOLLERR */
+       if ((x & Mono_Posix_EpollEvents_EPOLLET) == Mono_Posix_EpollEvents_EPOLLET)
+#ifdef EPOLLET
+               *r |= EPOLLET;
+#else /* def EPOLLET */
+               {errno = EINVAL; return -1;}
+#endif /* ndef EPOLLET */
+       if ((x & Mono_Posix_EpollEvents_EPOLLHUP) == Mono_Posix_EpollEvents_EPOLLHUP)
+#ifdef EPOLLHUP
+               *r |= EPOLLHUP;
+#else /* def EPOLLHUP */
+               {errno = EINVAL; return -1;}
+#endif /* ndef EPOLLHUP */
+       if ((x & Mono_Posix_EpollEvents_EPOLLIN) == Mono_Posix_EpollEvents_EPOLLIN)
+#ifdef EPOLLIN
+               *r |= EPOLLIN;
+#else /* def EPOLLIN */
+               {errno = EINVAL; return -1;}
+#endif /* ndef EPOLLIN */
+       if ((x & Mono_Posix_EpollEvents_EPOLLMSG) == Mono_Posix_EpollEvents_EPOLLMSG)
+#ifdef EPOLLMSG
+               *r |= EPOLLMSG;
+#else /* def EPOLLMSG */
+               {errno = EINVAL; return -1;}
+#endif /* ndef EPOLLMSG */
+       if ((x & Mono_Posix_EpollEvents_EPOLLONESHOT) == Mono_Posix_EpollEvents_EPOLLONESHOT)
+#ifdef EPOLLONESHOT
+               *r |= EPOLLONESHOT;
+#else /* def EPOLLONESHOT */
+               {errno = EINVAL; return -1;}
+#endif /* ndef EPOLLONESHOT */
+       if ((x & Mono_Posix_EpollEvents_EPOLLOUT) == Mono_Posix_EpollEvents_EPOLLOUT)
+#ifdef EPOLLOUT
+               *r |= EPOLLOUT;
+#else /* def EPOLLOUT */
+               {errno = EINVAL; return -1;}
+#endif /* ndef EPOLLOUT */
+       if ((x & Mono_Posix_EpollEvents_EPOLLPRI) == Mono_Posix_EpollEvents_EPOLLPRI)
+#ifdef EPOLLPRI
+               *r |= EPOLLPRI;
+#else /* def EPOLLPRI */
+               {errno = EINVAL; return -1;}
+#endif /* ndef EPOLLPRI */
+       if ((x & Mono_Posix_EpollEvents_EPOLLRDBAND) == Mono_Posix_EpollEvents_EPOLLRDBAND)
+#ifdef EPOLLRDBAND
+               *r |= EPOLLRDBAND;
+#else /* def EPOLLRDBAND */
+               {errno = EINVAL; return -1;}
+#endif /* ndef EPOLLRDBAND */
+       if ((x & Mono_Posix_EpollEvents_EPOLLRDHUP) == Mono_Posix_EpollEvents_EPOLLRDHUP)
+#ifdef EPOLLRDHUP
+               *r |= EPOLLRDHUP;
+#else /* def EPOLLRDHUP */
+               {errno = EINVAL; return -1;}
+#endif /* ndef EPOLLRDHUP */
+       if ((x & Mono_Posix_EpollEvents_EPOLLRDNORM) == Mono_Posix_EpollEvents_EPOLLRDNORM)
+#ifdef EPOLLRDNORM
+               *r |= EPOLLRDNORM;
+#else /* def EPOLLRDNORM */
+               {errno = EINVAL; return -1;}
+#endif /* ndef EPOLLRDNORM */
+       if ((x & Mono_Posix_EpollEvents_EPOLLWRBAND) == Mono_Posix_EpollEvents_EPOLLWRBAND)
+#ifdef EPOLLWRBAND
+               *r |= EPOLLWRBAND;
+#else /* def EPOLLWRBAND */
+               {errno = EINVAL; return -1;}
+#endif /* ndef EPOLLWRBAND */
+       if ((x & Mono_Posix_EpollEvents_EPOLLWRNORM) == Mono_Posix_EpollEvents_EPOLLWRNORM)
+#ifdef EPOLLWRNORM
+               *r |= EPOLLWRNORM;
+#else /* def EPOLLWRNORM */
+               {errno = EINVAL; return -1;}
+#endif /* ndef EPOLLWRNORM */
+       if (x == 0)
+               return 0;
+       return 0;
+}
+
+int Mono_Posix_ToEpollEvents (unsigned int x, unsigned int *r)
+{
+       *r = 0;
+       if (x == 0)
+               return 0;
+#ifdef EPOLLERR
+       if ((x & EPOLLERR) == EPOLLERR)
+               *r |= Mono_Posix_EpollEvents_EPOLLERR;
+#endif /* ndef EPOLLERR */
+#ifdef EPOLLET
+       if ((x & EPOLLET) == EPOLLET)
+               *r |= Mono_Posix_EpollEvents_EPOLLET;
+#endif /* ndef EPOLLET */
+#ifdef EPOLLHUP
+       if ((x & EPOLLHUP) == EPOLLHUP)
+               *r |= Mono_Posix_EpollEvents_EPOLLHUP;
+#endif /* ndef EPOLLHUP */
+#ifdef EPOLLIN
+       if ((x & EPOLLIN) == EPOLLIN)
+               *r |= Mono_Posix_EpollEvents_EPOLLIN;
+#endif /* ndef EPOLLIN */
+#ifdef EPOLLMSG
+       if ((x & EPOLLMSG) == EPOLLMSG)
+               *r |= Mono_Posix_EpollEvents_EPOLLMSG;
+#endif /* ndef EPOLLMSG */
+#ifdef EPOLLONESHOT
+       if ((x & EPOLLONESHOT) == EPOLLONESHOT)
+               *r |= Mono_Posix_EpollEvents_EPOLLONESHOT;
+#endif /* ndef EPOLLONESHOT */
+#ifdef EPOLLOUT
+       if ((x & EPOLLOUT) == EPOLLOUT)
+               *r |= Mono_Posix_EpollEvents_EPOLLOUT;
+#endif /* ndef EPOLLOUT */
+#ifdef EPOLLPRI
+       if ((x & EPOLLPRI) == EPOLLPRI)
+               *r |= Mono_Posix_EpollEvents_EPOLLPRI;
+#endif /* ndef EPOLLPRI */
+#ifdef EPOLLRDBAND
+       if ((x & EPOLLRDBAND) == EPOLLRDBAND)
+               *r |= Mono_Posix_EpollEvents_EPOLLRDBAND;
+#endif /* ndef EPOLLRDBAND */
+#ifdef EPOLLRDHUP
+       if ((x & EPOLLRDHUP) == EPOLLRDHUP)
+               *r |= Mono_Posix_EpollEvents_EPOLLRDHUP;
+#endif /* ndef EPOLLRDHUP */
+#ifdef EPOLLRDNORM
+       if ((x & EPOLLRDNORM) == EPOLLRDNORM)
+               *r |= Mono_Posix_EpollEvents_EPOLLRDNORM;
+#endif /* ndef EPOLLRDNORM */
+#ifdef EPOLLWRBAND
+       if ((x & EPOLLWRBAND) == EPOLLWRBAND)
+               *r |= Mono_Posix_EpollEvents_EPOLLWRBAND;
+#endif /* ndef EPOLLWRBAND */
+#ifdef EPOLLWRNORM
+       if ((x & EPOLLWRNORM) == EPOLLWRNORM)
+               *r |= Mono_Posix_EpollEvents_EPOLLWRNORM;
+#endif /* ndef EPOLLWRNORM */
+       return 0;
+}
+
+int Mono_Posix_FromEpollFlags (int x, int *r)
+{
+       *r = 0;
+       if ((x & Mono_Posix_EpollFlags_EPOLL_CLOEXEC) == Mono_Posix_EpollFlags_EPOLL_CLOEXEC)
+#ifdef EPOLL_CLOEXEC
+               *r |= EPOLL_CLOEXEC;
+#else /* def EPOLL_CLOEXEC */
+               {errno = EINVAL; return -1;}
+#endif /* ndef EPOLL_CLOEXEC */
+       if ((x & Mono_Posix_EpollFlags_EPOLL_NONBLOCK) == Mono_Posix_EpollFlags_EPOLL_NONBLOCK)
+#ifdef EPOLL_NONBLOCK
+               *r |= EPOLL_NONBLOCK;
+#else /* def EPOLL_NONBLOCK */
+               {errno = EINVAL; return -1;}
+#endif /* ndef EPOLL_NONBLOCK */
+       if (x == 0)
+               return 0;
+       return 0;
+}
+
+int Mono_Posix_ToEpollFlags (int x, int *r)
+{
+       *r = 0;
+       if (x == 0)
+               return 0;
+#ifdef EPOLL_CLOEXEC
+       if ((x & EPOLL_CLOEXEC) == EPOLL_CLOEXEC)
+               *r |= Mono_Posix_EpollFlags_EPOLL_CLOEXEC;
+#endif /* ndef EPOLL_CLOEXEC */
+#ifdef EPOLL_NONBLOCK
+       if ((x & EPOLL_NONBLOCK) == EPOLL_NONBLOCK)
+               *r |= Mono_Posix_EpollFlags_EPOLL_NONBLOCK;
+#endif /* ndef EPOLL_NONBLOCK */
+       return 0;
+}
+
 int Mono_Posix_FromErrno (int x, int *r)
 {
        *r = 0;

diff --git a/support/map.h b/support/map.h
index a2e59fd9309929873655afc9a2e39175216f6832..aab06b7b9cd87633ac75ad4b535a413d09a946db 100644 (file)
--- a/support/map.h
+++ b/support/map.h
@@ -147,6 +147,46 @@ enum Mono_Posix_DirectoryNotifyFlags {
 int Mono_Posix_FromDirectoryNotifyFlags (int x, int *r);
 int Mono_Posix_ToDirectoryNotifyFlags (int x, int *r);
 
+enum Mono_Posix_EpollEvents {
+       Mono_Posix_EpollEvents_EPOLLERR           = 0x00000008,
+       #define Mono_Posix_EpollEvents_EPOLLERR     Mono_Posix_EpollEvents_EPOLLERR
+       Mono_Posix_EpollEvents_EPOLLET            = 0x80000000,
+       #define Mono_Posix_EpollEvents_EPOLLET      Mono_Posix_EpollEvents_EPOLLET
+       Mono_Posix_EpollEvents_EPOLLHUP           = 0x00000010,
+       #define Mono_Posix_EpollEvents_EPOLLHUP     Mono_Posix_EpollEvents_EPOLLHUP
+       Mono_Posix_EpollEvents_EPOLLIN            = 0x00000001,
+       #define Mono_Posix_EpollEvents_EPOLLIN      Mono_Posix_EpollEvents_EPOLLIN
+       Mono_Posix_EpollEvents_EPOLLMSG           = 0x00000400,
+       #define Mono_Posix_EpollEvents_EPOLLMSG     Mono_Posix_EpollEvents_EPOLLMSG
+       Mono_Posix_EpollEvents_EPOLLONESHOT       = 0x40000000,
+       #define Mono_Posix_EpollEvents_EPOLLONESHOT Mono_Posix_EpollEvents_EPOLLONESHOT
+       Mono_Posix_EpollEvents_EPOLLOUT           = 0x00000004,
+       #define Mono_Posix_EpollEvents_EPOLLOUT     Mono_Posix_EpollEvents_EPOLLOUT
+       Mono_Posix_EpollEvents_EPOLLPRI           = 0x00000002,
+       #define Mono_Posix_EpollEvents_EPOLLPRI     Mono_Posix_EpollEvents_EPOLLPRI
+       Mono_Posix_EpollEvents_EPOLLRDBAND        = 0x00000080,
+       #define Mono_Posix_EpollEvents_EPOLLRDBAND  Mono_Posix_EpollEvents_EPOLLRDBAND
+       Mono_Posix_EpollEvents_EPOLLRDHUP         = 0x00002000,
+       #define Mono_Posix_EpollEvents_EPOLLRDHUP   Mono_Posix_EpollEvents_EPOLLRDHUP
+       Mono_Posix_EpollEvents_EPOLLRDNORM        = 0x00000040,
+       #define Mono_Posix_EpollEvents_EPOLLRDNORM  Mono_Posix_EpollEvents_EPOLLRDNORM
+       Mono_Posix_EpollEvents_EPOLLWRBAND        = 0x00000200,
+       #define Mono_Posix_EpollEvents_EPOLLWRBAND  Mono_Posix_EpollEvents_EPOLLWRBAND
+       Mono_Posix_EpollEvents_EPOLLWRNORM        = 0x00000100,
+       #define Mono_Posix_EpollEvents_EPOLLWRNORM  Mono_Posix_EpollEvents_EPOLLWRNORM
+};
+int Mono_Posix_FromEpollEvents (unsigned int x, unsigned int *r);
+int Mono_Posix_ToEpollEvents (unsigned int x, unsigned int *r);
+
+enum Mono_Posix_EpollFlags {
+       Mono_Posix_EpollFlags_EPOLL_CLOEXEC        = 0x001e8480,
+       #define Mono_Posix_EpollFlags_EPOLL_CLOEXEC  Mono_Posix_EpollFlags_EPOLL_CLOEXEC
+       Mono_Posix_EpollFlags_EPOLL_NONBLOCK       = 0x00000fa0,
+       #define Mono_Posix_EpollFlags_EPOLL_NONBLOCK Mono_Posix_EpollFlags_EPOLL_NONBLOCK
+};
+int Mono_Posix_FromEpollFlags (int x, int *r);
+int Mono_Posix_ToEpollFlags (int x, int *r);
+
 enum Mono_Posix_Errno {
        Mono_Posix_Errno_E2BIG                 = 0x00000007,
        #define Mono_Posix_Errno_E2BIG           Mono_Posix_Errno_E2BIG