?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[LoongArch64] Part-5:add loongarch support in some files for LoongArch64. (#21769)
[mono-project.git] / mcs / class / corlib / System.IO / MonoIO.cs
blob46774397bcdc3677b0e8a1cb332088e8d3468254
1 // System.IO.MonoIO.cs: static interface to native filesystem.
2 //
3 // Author:
4 // Dan Lewis (dihlewis@yahoo.co.uk)
5 // Dick Porter (dick@ximian.com)
6 //
7 // (C) 2002
8 // Copyright 2011 Xamarin Inc (http://www.xamarin.com).
9 //
10
11 //
12 // Copyright (C) 2004 Novell, Inc (http://www.novell.com)
13 //
14 // Permission is hereby granted, free of charge, to any person obtaining
15 // a copy of this software and associated documentation files (the
16 // "Software"), to deal in the Software without restriction, including
17 // without limitation the rights to use, copy, modify, merge, publish,
18 // distribute, sublicense, and/or sell copies of the Software, and to
19 // permit persons to whom the Software is furnished to do so, subject to
20 // the following conditions:
21 //
22 // The above copyright notice and this permission notice shall be
23 // included in all copies or substantial portions of the Software.
24 //
25 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
26 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
27 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
28 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
29 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
30 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
31 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
32 //
33
34 using System;
35 using System.Runtime.CompilerServices;
36 using System.Runtime.InteropServices;
37 using System.Threading;
38 using Microsoft.Win32.SafeHandles;
39 #if MOBILE
40 using System.IO.IsolatedStorage;
41 #endif
42
43 namespace System.IO
44 {
45 unsafe static class MonoIO {
46 public const int FileAlreadyExistsHResult = unchecked ((int) 0x80070000) | (int)MonoIOError.ERROR_FILE_EXISTS;
47
48 public const FileAttributes
49 InvalidFileAttributes = (FileAttributes)(-1);
50
51 public static readonly IntPtr
52 InvalidHandle = (IntPtr)(-1L);
53
54 static bool dump_handles = Environment.GetEnvironmentVariable ("MONO_DUMP_HANDLES_ON_ERROR_TOO_MANY_OPEN_FILES") != null;
55
56 // error methods
57 public static Exception GetException (MonoIOError error)
58 {
59 /* This overload is currently only called from
60 * File.MoveFile(), Directory.Move() and
61 * Directory.GetCurrentDirectory() -
62 * everywhere else supplies a path to format
63 * with the error text.
64 */
65 switch(error) {
66 case MonoIOError.ERROR_ACCESS_DENIED:
67 return new UnauthorizedAccessException ("Access to the path is denied.");
68 case MonoIOError.ERROR_FILE_EXISTS:
69 string message = "Cannot create a file that already exist.";
70 return new IOException (message, FileAlreadyExistsHResult);
71 default:
72 /* Add more mappings here if other
73 * errors trigger the named but empty
74 * path bug (see bug 82141.) For
75 * everything else, fall through to
76 * the other overload
77 */
78 return GetException (String.Empty, error);
79 }
80 }
81
82 public static Exception GetException (string path,
83 MonoIOError error)
84 {
85 string message;
86
87 switch (error) {
88 // FIXME: add more exception mappings here
89 case MonoIOError.ERROR_FILE_NOT_FOUND:
90 message = String.Format ("Could not find file \"{0}\"", path);
91 return new FileNotFoundException (message, path);
92
93 case MonoIOError.ERROR_TOO_MANY_OPEN_FILES:
94 if (dump_handles)
95 DumpHandles ();
96 return new IOException ("Too many open files", unchecked((int)0x80070000) | (int)error);
97
98 case MonoIOError.ERROR_PATH_NOT_FOUND:
99 message = String.Format ("Could not find a part of the path \"{0}\"", path);
100 return new DirectoryNotFoundException (message);
101
102 case MonoIOError.ERROR_ACCESS_DENIED:
103 message = String.Format ("Access to the path \"{0}\" is denied.", path);
104 return new UnauthorizedAccessException (message);
105
106 case MonoIOError.ERROR_INVALID_HANDLE:
107 message = String.Format ("Invalid handle to path \"{0}\"", path);
108 return new IOException (message, unchecked((int)0x80070000) | (int)error);
109 case MonoIOError.ERROR_INVALID_DRIVE:
110 message = String.Format ("Could not find the drive '{0}'. The drive might not be ready or might not be mapped.", path);
111 #if !MOBILE
112 return new DriveNotFoundException (message);
113 #else
114 return new IOException (message, unchecked((int)0x80070000) | (int)error);
115 #endif
116 case MonoIOError.ERROR_FILE_EXISTS:
117 message = String.Format ("Could not create file \"{0}\". File already exists.", path);
118 return new IOException (message, unchecked((int)0x80070000) | (int)error);
119
120 case MonoIOError.ERROR_FILENAME_EXCED_RANGE:
121 message = String.Format ("Path is too long. Path: {0}", path);
122 return new PathTooLongException (message);
123
124 case MonoIOError.ERROR_INVALID_PARAMETER:
125 message = String.Format ("Invalid parameter");
126 return new IOException (message, unchecked((int)0x80070000) | (int)error);
127
128 case MonoIOError.ERROR_WRITE_FAULT:
129 message = String.Format ("Write fault on path {0}", path);
130 return new IOException (message, unchecked((int)0x80070000) | (int)error);
131
132 case MonoIOError.ERROR_SHARING_VIOLATION:
133 message = String.Format ("Sharing violation on path {0}", path);
134 return new IOException (message, unchecked((int)0x80070000) | (int)error);
135
136 case MonoIOError.ERROR_LOCK_VIOLATION:
137 message = String.Format ("Lock violation on path {0}", path);
138 return new IOException (message, unchecked((int)0x80070000) | (int)error);
139
140 case MonoIOError.ERROR_HANDLE_DISK_FULL:
141 message = String.Format ("Disk full. Path {0}", path);
142 return new IOException (message, unchecked((int)0x80070000) | (int)error);
143
144 case MonoIOError.ERROR_DIR_NOT_EMPTY:
145 message = String.Format ("Directory {0} is not empty", path);
146 return new IOException (message, unchecked((int)0x80070000) | (int)error);
147
148 case MonoIOError.ERROR_ENCRYPTION_FAILED:
149 return new IOException ("Encryption failed", unchecked((int)0x80070000) | (int)error);
150
151 case MonoIOError.ERROR_CANNOT_MAKE:
152 message = String.Format ("Path {0} is a directory", path);
153 return new IOException (message, unchecked((int)0x80070000) | (int)error);
154
155 case MonoIOError.ERROR_NOT_SAME_DEVICE:
156 message = "Source and destination are not on the same device";
157 return new IOException (message, unchecked((int)0x80070000) | (int)error);
158
159 case MonoIOError.ERROR_DIRECTORY:
160 message = "The directory name is invalid";
161 return new IOException (message, unchecked((int)0x80070000) | (int)error);
162
163 default:
164 message = String.Format ("Win32 IO returned {0}. Path: {1}", error, path);
165 return new IOException (message, unchecked((int)0x80070000) | (int)error);
166 }
167 }
168
169 // directory methods
170
171 [MethodImplAttribute (MethodImplOptions.InternalCall)]
172 private unsafe extern static bool CreateDirectory (char* path, out MonoIOError error);
173
174 public static bool CreateDirectory (string path, out MonoIOError error)
175 {
176 unsafe {
177 fixed (char* pathChars = path) {
178 return CreateDirectory (pathChars, out error);
179 }
180 }
181 }
182
183 [MethodImplAttribute (MethodImplOptions.InternalCall)]
184 private unsafe extern static bool RemoveDirectory (char* path, out MonoIOError error);
185
186 public static bool RemoveDirectory (string path, out MonoIOError error)
187 {
188 unsafe {
189 fixed (char* pathChars = path) {
190 return RemoveDirectory (pathChars, out error);
191 }
192 }
193 }
194
195 [MethodImplAttribute (MethodImplOptions.InternalCall)]
196 public extern static string GetCurrentDirectory (out MonoIOError error);
197
198 [MethodImplAttribute (MethodImplOptions.InternalCall)]
199 private unsafe extern static bool SetCurrentDirectory (char* path, out MonoIOError error);
200
201 public static bool SetCurrentDirectory (string path, out MonoIOError error)
202 {
203 unsafe {
204 fixed (char* pathChars = path) {
205 return SetCurrentDirectory (pathChars, out error);
206 }
207 }
208 }
209
210 // file methods
211
212 [MethodImplAttribute (MethodImplOptions.InternalCall)]
213 private unsafe extern static bool MoveFile (char* path, char* dest,
214 out MonoIOError error);
215
216 public static bool MoveFile (string path, string dest,
217 out MonoIOError error)
218 {
219 unsafe {
220 fixed (char* pathChars = path, destChars = dest) {
221 return MoveFile (pathChars, destChars, out error);
222 }
223 }
224 }
225
226 [MethodImplAttribute (MethodImplOptions.InternalCall)]
227 private unsafe extern static bool CopyFile (char* path, char* dest,
228 bool overwrite,
229 out MonoIOError error);
230
231 public static bool CopyFile (string path, string dest,
232 bool overwrite,
233 out MonoIOError error)
234 {
235 unsafe {
236 fixed (char* pathChars = path, destChars = dest) {
237 return CopyFile (pathChars, destChars, overwrite, out error);
238 }
239 }
240 }
241
242 [MethodImplAttribute (MethodImplOptions.InternalCall)]
243 private unsafe extern static bool DeleteFile (char* path,
244 out MonoIOError error);
245
246 public static bool DeleteFile (string path,
247 out MonoIOError error)
248 {
249 unsafe {
250 fixed (char* pathChars = path) {
251 return DeleteFile (pathChars, out error);
252 }
253 }
254 }
255
256 [MethodImplAttribute (MethodImplOptions.InternalCall)]
257 private unsafe extern static bool ReplaceFile (char* sourceFileName,
258 char* destinationFileName,
259 char* destinationBackupFileName,
260 bool ignoreMetadataErrors,
261 out MonoIOError error);
262
263 public static bool ReplaceFile (string sourceFileName,
264 string destinationFileName,
265 string destinationBackupFileName,
266 bool ignoreMetadataErrors,
267 out MonoIOError error)
268 {
269 unsafe {
270 fixed (char* sourceFileNameChars = sourceFileName,
271 destinationFileNameChars = destinationFileName,
272 destinationBackupFileNameChars = destinationBackupFileName) {
273 return ReplaceFile (sourceFileNameChars, destinationFileNameChars, destinationBackupFileNameChars, ignoreMetadataErrors, out error);
274 }
275 }
276 }
277
278 [MethodImplAttribute (MethodImplOptions.InternalCall)]
279 private unsafe extern static FileAttributes GetFileAttributes (char* path, out MonoIOError error);
280
281 public static FileAttributes GetFileAttributes (string path, out MonoIOError error)
282 {
283 unsafe {
284 fixed (char* pathChars = path) {
285 return GetFileAttributes (pathChars, out error);
286 }
287 }
288 }
289
290 [MethodImplAttribute (MethodImplOptions.InternalCall)]
291 private extern static bool SetFileAttributes (char* path, FileAttributes attrs, out MonoIOError error);
292
293 public static bool SetFileAttributes (string path, FileAttributes attrs, out MonoIOError error)
294 {
295 unsafe {
296 fixed (char* pathChars = path) {
297 return SetFileAttributes (pathChars, attrs, out error);
298 }
299 }
300 }
301
302 [MethodImplAttribute (MethodImplOptions.InternalCall)]
303 private extern static MonoFileType GetFileType (IntPtr handle, out MonoIOError error);
304
305 public static MonoFileType GetFileType (SafeHandle safeHandle, out MonoIOError error)
306 {
307 bool release = false;
308 try {
309 safeHandle.DangerousAddRef (ref release);
310 return GetFileType (safeHandle.DangerousGetHandle (), out error);
311 } finally {
312 if (release)
313 safeHandle.DangerousRelease ();
314 }
315 }
316
317 //
318 // Find file methods
319 //
320
321 [MethodImplAttribute (MethodImplOptions.InternalCall)]
322 private unsafe extern static IntPtr FindFirstFile (char* pathWithPattern, out string fileName, out int fileAttr, out int error);
323
324 public static IntPtr FindFirstFile (string pathWithPattern, out string fileName, out int fileAttr, out int error)
325 {
326 unsafe {
327 fixed (char* pathWithPatternChars = pathWithPattern) {
328 return FindFirstFile (pathWithPatternChars, out fileName, out fileAttr, out error);
329 }
330 }
331 }
332
333 [MethodImplAttribute (MethodImplOptions.InternalCall)]
334 public extern static bool FindNextFile (IntPtr hnd, out string fileName, out int fileAttr, out int error);
335
336 [MethodImplAttribute (MethodImplOptions.InternalCall)]
337 public extern static bool FindCloseFile (IntPtr hnd);
338
339 public static bool Exists (string path, out MonoIOError error)
340 {
341 FileAttributes attrs = GetFileAttributes (path,
342 out error);
343 if (attrs == InvalidFileAttributes)
344 return false;
345
346 return true;
347 }
348
349 public static bool ExistsFile (string path,
350 out MonoIOError error)
351 {
352 FileAttributes attrs = GetFileAttributes (path,
353 out error);
354 if (attrs == InvalidFileAttributes)
355 return false;
356
357 if ((attrs & FileAttributes.Directory) != 0)
358 return false;
359
360 return true;
361 }
362
363 public static bool ExistsDirectory (string path,
364 out MonoIOError error)
365 {
366 FileAttributes attrs = GetFileAttributes (path,
367 out error);
368
369 // Actually, we are looking for a directory, not a file
370 if (error == MonoIOError.ERROR_FILE_NOT_FOUND)
371 error = MonoIOError.ERROR_PATH_NOT_FOUND;
372
373 if (attrs == InvalidFileAttributes)
374 return false;
375
376 if ((attrs & FileAttributes.Directory) == 0)
377 return false;
378
379 return true;
380 }
381
382 public static bool ExistsSymlink (string path,
383 out MonoIOError error)
384 {
385 FileAttributes attrs = GetFileAttributes (path,
386 out error);
387 if (attrs == InvalidFileAttributes)
388 return false;
389
390 if ((attrs & FileAttributes.ReparsePoint) == 0)
391 return false;
392
393 return true;
394 }
395
396 [MethodImplAttribute (MethodImplOptions.InternalCall)]
397 private unsafe extern static bool GetFileStat (char* path,
398 out MonoIOStat stat,
399 out MonoIOError error);
400
401 public static bool GetFileStat (string path,
402 out MonoIOStat stat,
403 out MonoIOError error)
404 {
405 unsafe {
406 fixed (char* pathChars = path) {
407 return GetFileStat (pathChars, out stat, out error);
408 }
409 }
410 }
411
412 // handle methods
413
414 [MethodImplAttribute (MethodImplOptions.InternalCall)]
415 private unsafe extern static IntPtr Open (char* filename,
416 FileMode mode,
417 FileAccess access,
418 FileShare share,
419 FileOptions options,
420 out MonoIOError error);
421
422 public static IntPtr Open (string filename,
423 FileMode mode,
424 FileAccess access,
425 FileShare share,
426 FileOptions options,
427 out MonoIOError error)
428 {
429 unsafe {
430 fixed (char* filenameChars = filename) {
431 return Open (filenameChars, mode, access, share, options, out error);
432 }
433 }
434 }
435
436 [MethodImplAttribute (MethodImplOptions.InternalCall)]
437 private extern static bool Cancel_internal (IntPtr handle, out MonoIOError error);
438
439 internal static bool Cancel (SafeHandle safeHandle, out MonoIOError error)
440 {
441 bool release = false;
442 try {
443 safeHandle.DangerousAddRef (ref release);
444 return Cancel_internal (safeHandle.DangerousGetHandle (), out error);
445 } finally {
446 if (release)
447 safeHandle.DangerousRelease ();
448 }
449 }
450
451 [MethodImplAttribute (MethodImplOptions.InternalCall)]
452 public extern static bool Close (IntPtr handle,
453 out MonoIOError error);
454
455 [MethodImplAttribute (MethodImplOptions.InternalCall)]
456 private extern static int Read (IntPtr handle, byte [] dest,
457 int dest_offset, int count,
458 out MonoIOError error);
459
460 public static int Read (SafeHandle safeHandle, byte [] dest,
461 int dest_offset, int count,
462 out MonoIOError error)
463 {
464 bool release = false;
465 try {
466 safeHandle.DangerousAddRef (ref release);
467 return Read (safeHandle.DangerousGetHandle (), dest, dest_offset, count, out error);
468 } finally {
469 if (release)
470 safeHandle.DangerousRelease ();
471 }
472 }
473
474 [MethodImplAttribute (MethodImplOptions.InternalCall)]
475 private extern static int Write (IntPtr handle, [In] byte [] src,
476 int src_offset, int count,
477 out MonoIOError error);
478
479 public static int Write (SafeHandle safeHandle, byte [] src,
480 int src_offset, int count,
481 out MonoIOError error)
482 {
483 bool release = false;
484 try {
485 safeHandle.DangerousAddRef (ref release);
486 return Write (safeHandle.DangerousGetHandle (), src, src_offset, count, out error);
487 } finally {
488 if (release)
489 safeHandle.DangerousRelease ();
490 }
491 }
492
493 [MethodImplAttribute (MethodImplOptions.InternalCall)]
494 private extern static long Seek (IntPtr handle, long offset,
495 SeekOrigin origin,
496 out MonoIOError error);
497
498 public static long Seek (SafeHandle safeHandle, long offset,
499 SeekOrigin origin,
500 out MonoIOError error)
501 {
502 bool release = false;
503 try {
504 safeHandle.DangerousAddRef (ref release);
505 return Seek (safeHandle.DangerousGetHandle (), offset, origin, out error);
506 } finally {
507 if (release)
508 safeHandle.DangerousRelease ();
509 }
510 }
511
512 [MethodImplAttribute (MethodImplOptions.InternalCall)]
513 private extern static bool Flush (IntPtr handle,
514 out MonoIOError error);
515
516 public static bool Flush (SafeHandle safeHandle,
517 out MonoIOError error)
518 {
519 bool release = false;
520 try {
521 safeHandle.DangerousAddRef (ref release);
522 return Flush (safeHandle.DangerousGetHandle (), out error);
523 } finally {
524 if (release)
525 safeHandle.DangerousRelease ();
526 }
527 }
528
529 [MethodImplAttribute (MethodImplOptions.InternalCall)]
530 private extern static long GetLength (IntPtr handle,
531 out MonoIOError error);
532
533 public static long GetLength (SafeHandle safeHandle,
534 out MonoIOError error)
535 {
536 bool release = false;
537 try {
538 safeHandle.DangerousAddRef (ref release);
539 return GetLength (safeHandle.DangerousGetHandle (), out error);
540 } finally {
541 if (release)
542 safeHandle.DangerousRelease ();
543 }
544 }
545
546 [MethodImplAttribute (MethodImplOptions.InternalCall)]
547 private extern static bool SetLength (IntPtr handle,
548 long length,
549 out MonoIOError error);
550
551 public static bool SetLength (SafeHandle safeHandle,
552 long length,
553 out MonoIOError error)
554 {
555 bool release = false;
556 try {
557 safeHandle.DangerousAddRef (ref release);
558 return SetLength (safeHandle.DangerousGetHandle (), length, out error);
559 } finally {
560 if (release)
561 safeHandle.DangerousRelease ();
562 }
563 }
564
565 [MethodImplAttribute (MethodImplOptions.InternalCall)]
566 private extern static bool SetFileTime (IntPtr handle,
567 long creation_time,
568 long last_access_time,
569 long last_write_time,
570 out MonoIOError error);
571
572 public static bool SetFileTime (SafeHandle safeHandle,
573 long creation_time,
574 long last_access_time,
575 long last_write_time,
576 out MonoIOError error)
577 {
578 bool release = false;
579 try {
580 safeHandle.DangerousAddRef (ref release);
581 return SetFileTime (safeHandle.DangerousGetHandle (), creation_time, last_access_time, last_write_time, out error);
582 } finally {
583 if (release)
584 safeHandle.DangerousRelease ();
585 }
586 }
587
588 public static bool SetFileTime (string path,
589 long creation_time,
590 long last_access_time,
591 long last_write_time,
592 out MonoIOError error)
593 {
594 return SetFileTime (path,
595 0,
596 creation_time,
597 last_access_time,
598 last_write_time,
599 DateTime.MinValue,
600 out error);
601 }
602
603 public static bool SetCreationTime (string path,
604 DateTime dateTime,
605 out MonoIOError error)
606 {
607 return SetFileTime (path, 1, -1, -1, -1, dateTime, out error);
608 }
609
610 public static bool SetLastAccessTime (string path,
611 DateTime dateTime,
612 out MonoIOError error)
613 {
614 return SetFileTime (path, 2, -1, -1, -1, dateTime, out error);
615 }
616
617 public static bool SetLastWriteTime (string path,
618 DateTime dateTime,
619 out MonoIOError error)
620 {
621 return SetFileTime (path, 3, -1, -1, -1, dateTime, out error);
622 }
623
624 public static bool SetFileTime (string path,
625 int type,
626 long creation_time,
627 long last_access_time,
628 long last_write_time,
629 DateTime dateTime,
630 out MonoIOError error)
631 {
632 IntPtr handle;
633 bool result;
634
635 handle = Open (path, FileMode.Open,
636 FileAccess.ReadWrite,
637 FileShare.ReadWrite, FileOptions.None, out error);
638 if (handle == MonoIO.InvalidHandle)
639 return false;
640
641 switch (type) {
642 case 1:
643 creation_time = dateTime.ToFileTime ();
644 break;
645 case 2:
646 last_access_time = dateTime.ToFileTime ();
647 break;
648 case 3:
649 last_write_time = dateTime.ToFileTime ();
650 break;
651 }
652
653 result = SetFileTime (new SafeFileHandle(handle, false), creation_time,
654 last_access_time,
655 last_write_time, out error);
656
657 MonoIOError ignore_error;
658 Close (handle, out ignore_error);
659
660 return result;
661 }
662
663 [MethodImplAttribute (MethodImplOptions.InternalCall)]
664 private extern static void Lock (IntPtr handle,
665 long position, long length,
666 out MonoIOError error);
667
668 public static void Lock (SafeHandle safeHandle,
669 long position, long length,
670 out MonoIOError error)
671 {
672 bool release = false;
673 try {
674 safeHandle.DangerousAddRef (ref release);
675 Lock (safeHandle.DangerousGetHandle (), position, length, out error);
676 } finally {
677 if (release)
678 safeHandle.DangerousRelease ();
679 }
680 }
681
682 [MethodImplAttribute (MethodImplOptions.InternalCall)]
683 private extern static void Unlock (IntPtr handle,
684 long position, long length,
685 out MonoIOError error);
686
687 public static void Unlock (SafeHandle safeHandle,
688 long position, long length,
689 out MonoIOError error)
690 {
691 bool release = false;
692 try {
693 safeHandle.DangerousAddRef (ref release);
694 Unlock (safeHandle.DangerousGetHandle (), position, length, out error);
695 } finally {
696 if (release)
697 safeHandle.DangerousRelease ();
698 }
699 }
700
701 // console handles
702
703 public extern static IntPtr ConsoleOutput {
704 [MethodImplAttribute (MethodImplOptions.InternalCall)]
705 get;
706 }
707
708 public extern static IntPtr ConsoleInput {
709 [MethodImplAttribute (MethodImplOptions.InternalCall)]
710 get;
711 }
712
713 public extern static IntPtr ConsoleError {
714 [MethodImplAttribute (MethodImplOptions.InternalCall)]
715 get;
716 }
717
718 // pipe handles
719
720 [MethodImplAttribute (MethodImplOptions.InternalCall)]
721 public extern static bool CreatePipe (out IntPtr read_handle, out IntPtr write_handle, out MonoIOError error);
722
723 [MethodImplAttribute (MethodImplOptions.InternalCall)]
724 public extern static bool DuplicateHandle (IntPtr source_process_handle, IntPtr source_handle,
725 IntPtr target_process_handle, out IntPtr target_handle, int access, int inherit, int options, out MonoIOError error);
726
727 // path characters
728
729 public extern static char VolumeSeparatorChar {
730 [MethodImplAttribute (MethodImplOptions.InternalCall)]
731 get;
732 }
733
734 public extern static char DirectorySeparatorChar {
735 [MethodImplAttribute (MethodImplOptions.InternalCall)]
736 get;
737 }
738
739 public extern static char AltDirectorySeparatorChar {
740 [MethodImplAttribute (MethodImplOptions.InternalCall)]
741 get;
742 }
743
744 public extern static char PathSeparator {
745 [MethodImplAttribute (MethodImplOptions.InternalCall)]
746 get;
747 }
748
749 [MethodImplAttribute (MethodImplOptions.InternalCall)]
750 extern static void DumpHandles ();
751 }
752 }
753
Mirror of the official Mono project git repository