[corlib] CompressedStack in not supported in mobile profile

[mono.git] / mcs / class / corlib / System.IO / MonoIO.cs

diff --git a/mcs/class/corlib/System.IO/MonoIO.cs b/mcs/class/corlib/System.IO/MonoIO.cs
index c7cdc3772ebb98d9757de8d1af2f8352185e6f3b..e195b080e88a46caf773b94523756541894c0c7b 100644 (file)
--- a/mcs/class/corlib/System.IO/MonoIO.cs
+++ b/mcs/class/corlib/System.IO/MonoIO.cs
@@ -204,7 +204,19 @@ namespace System.IO
                public extern static bool SetFileAttributes (string path, FileAttributes attrs, out MonoIOError error);
 
                [MethodImplAttribute (MethodImplOptions.InternalCall)]
-               public extern static MonoFileType GetFileType (SafeHandle safeHandle, out MonoIOError error);
+               private extern static MonoFileType GetFileType (IntPtr handle, out MonoIOError error);
+
+               public static MonoFileType GetFileType (SafeHandle safeHandle, out MonoIOError error)
+               {
+                       bool release = false;
+                       try {
+                               safeHandle.DangerousAddRef (ref release);
+                               return GetFileType (safeHandle.DangerousGetHandle (), out error);
+                       } finally {
+                               if (release)
+                                       safeHandle.DangerousRelease ();
+                       }
+               }
 
                //
                // Find file methods
@@ -295,40 +307,138 @@ namespace System.IO
                                                 out MonoIOError error);
                
                [MethodImplAttribute (MethodImplOptions.InternalCall)]
-               public extern static int Read (SafeHandle safeHandle, byte [] dest,
+               private extern static int Read (IntPtr handle, byte [] dest,
                                               int dest_offset, int count,
                                               out MonoIOError error);
+
+               public static int Read (SafeHandle safeHandle, byte [] dest,
+                                              int dest_offset, int count,
+                                              out MonoIOError error)
+               {
+                       bool release = false;
+                       try {
+                               safeHandle.DangerousAddRef (ref release);
+                               return Read (safeHandle.DangerousGetHandle (), dest, dest_offset, count, out error);
+                       } finally {
+                               if (release)
+                                       safeHandle.DangerousRelease ();
+                       }
+               }
                
                [MethodImplAttribute (MethodImplOptions.InternalCall)]
-               public extern static int Write (SafeHandle safeHandle, [In] byte [] src,
+               private extern static int Write (IntPtr handle, [In] byte [] src,
                                                int src_offset, int count,
                                                out MonoIOError error);
+
+               public static int Write (SafeHandle safeHandle, byte [] src,
+                                               int src_offset, int count,
+                                               out MonoIOError error)
+               {
+                       bool release = false;
+                       try {
+                               safeHandle.DangerousAddRef (ref release);
+                               return Write (safeHandle.DangerousGetHandle (), src, src_offset, count, out error);
+                       } finally {
+                               if (release)
+                                       safeHandle.DangerousRelease ();
+                       }
+               }
                
                [MethodImplAttribute (MethodImplOptions.InternalCall)]
-               public extern static long Seek (SafeHandle safeHandle, long offset,
+               private extern static long Seek (IntPtr handle, long offset,
                                                SeekOrigin origin,
                                                out MonoIOError error);
+
+               public static long Seek (SafeHandle safeHandle, long offset,
+                                               SeekOrigin origin,
+                                               out MonoIOError error)
+               {
+                       bool release = false;
+                       try {
+                               safeHandle.DangerousAddRef (ref release);
+                               return Seek (safeHandle.DangerousGetHandle (), offset, origin, out error);
+                       } finally {
+                               if (release)
+                                       safeHandle.DangerousRelease ();
+                       }
+               }
                
                [MethodImplAttribute (MethodImplOptions.InternalCall)]
-               public extern static bool Flush (SafeHandle safeHandle,
+               private extern static bool Flush (IntPtr handle,
                                                 out MonoIOError error);
 
+               public static bool Flush (SafeHandle safeHandle,
+                                                out MonoIOError error)
+               {
+                       bool release = false;
+                       try {
+                               safeHandle.DangerousAddRef (ref release);
+                               return Flush (safeHandle.DangerousGetHandle (), out error);
+                       } finally {
+                               if (release)
+                                       safeHandle.DangerousRelease ();
+                       }
+               }
+
                [MethodImplAttribute (MethodImplOptions.InternalCall)]
-               public extern static long GetLength (SafeHandle handle,
+               private extern static long GetLength (IntPtr handle,
                                                     out MonoIOError error);
 
+               public static long GetLength (SafeHandle safeHandle,
+                                                    out MonoIOError error)
+               {
+                       bool release = false;
+                       try {
+                               safeHandle.DangerousAddRef (ref release);
+                               return GetLength (safeHandle.DangerousGetHandle (), out error);
+                       } finally {
+                               if (release)
+                                       safeHandle.DangerousRelease ();
+                       }
+               }
+
                [MethodImplAttribute (MethodImplOptions.InternalCall)]
-               public extern static bool SetLength (SafeHandle safeHandle,
+               private extern static bool SetLength (IntPtr handle,
                                                     long length,
                                                     out MonoIOError error);
 
+               public static bool SetLength (SafeHandle safeHandle,
+                                                    long length,
+                                                    out MonoIOError error)
+               {
+                       bool release = false;
+                       try {
+                               safeHandle.DangerousAddRef (ref release);
+                               return SetLength (safeHandle.DangerousGetHandle (), length, out error);
+                       } finally {
+                               if (release)
+                                       safeHandle.DangerousRelease ();
+                       }
+               }
+
                [MethodImplAttribute (MethodImplOptions.InternalCall)]
-               public extern static bool SetFileTime (SafeHandle safeHandle,
+               private extern static bool SetFileTime (IntPtr handle,
                                                       long creation_time,
                                                       long last_access_time,
                                                       long last_write_time,
                                                       out MonoIOError error);
 
+               public static bool SetFileTime (SafeHandle safeHandle,
+                                                      long creation_time,
+                                                      long last_access_time,
+                                                      long last_write_time,
+                                                      out MonoIOError error)
+               {
+                       bool release = false;
+                       try {
+                               safeHandle.DangerousAddRef (ref release);
+                               return SetFileTime (safeHandle.DangerousGetHandle (), creation_time, last_access_time, last_write_time, out error);
+                       } finally {
+                               if (release)
+                                       safeHandle.DangerousRelease ();
+                       }
+               }
+
                public static bool SetFileTime (string path,
                                                long creation_time,
                                                long last_access_time,
@@ -405,15 +515,43 @@ namespace System.IO
                }
 
                [MethodImplAttribute (MethodImplOptions.InternalCall)]
-               public extern static void Lock (SafeHandle safeHandle,
+               private extern static void Lock (IntPtr handle,
                                                long position, long length,
                                                out MonoIOError error);
 
+               public static void Lock (SafeHandle safeHandle,
+                                               long position, long length,
+                                               out MonoIOError error)
+               {
+                       bool release = false;
+                       try {
+                               safeHandle.DangerousAddRef (ref release);
+                               Lock (safeHandle.DangerousGetHandle (), position, length, out error);
+                       } finally {
+                               if (release)
+                                       safeHandle.DangerousRelease ();
+                       }
+               }
+
                [MethodImplAttribute (MethodImplOptions.InternalCall)]
-               public extern static void Unlock (SafeHandle safeHandle,
+               private extern static void Unlock (IntPtr handle,
                                                  long position, long length,
                                                  out MonoIOError error);
 
+               public static void Unlock (SafeHandle safeHandle,
+                                                 long position, long length,
+                                                 out MonoIOError error)
+               {
+                       bool release = false;
+                       try {
+                               safeHandle.DangerousAddRef (ref release);
+                               Unlock (safeHandle.DangerousGetHandle (), position, length, out error);
+                       } finally {
+                               if (release)
+                                       safeHandle.DangerousRelease ();
+                       }
+               }
+
                // console handles
 
                public extern static IntPtr ConsoleOutput {