?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
2010-05-27 Jb Evain <jbevain@novell.com>
[mcs.git] / class / corlib / System.Runtime.InteropServices / Marshal.cs
blobfa0344c771e185b9b0bf8ce078f780851b8e666d
1 // System.Runtime.InteropServices.Marshal.cs
2 //
3 // Sean MacIsaac (macisaac@ximian.com)
4 // Paolo Molaro (lupus@ximian.com)
5 // Dietmar Maurer (dietmar@ximian.com)
6 // Jonathan Chambers (joncham@gmail.com)
7 //
8 // (C) 2001-2002 Ximian, Inc.
9
10 //
11 // Copyright (C) 2004 Novell, Inc (http://www.novell.com)
12 //
13 // Permission is hereby granted, free of charge, to any person obtaining
14 // a copy of this software and associated documentation files (the
15 // "Software"), to deal in the Software without restriction, including
16 // without limitation the rights to use, copy, modify, merge, publish,
17 // distribute, sublicense, and/or sell copies of the Software, and to
18 // permit persons to whom the Software is furnished to do so, subject to
19 // the following conditions:
20 //
21 // The above copyright notice and this permission notice shall be
22 // included in all copies or substantial portions of the Software.
23 //
24 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
25 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
26 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
27 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
28 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
29 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
30 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
31 //
32
33 using System.Collections;
34 using System.Runtime.CompilerServices;
35 using System;
36 using System.Security;
37 using System.Reflection;
38 using System.Threading;
39
40 using System.Runtime.ConstrainedExecution;
41 #if !MOONLIGHT
42 using System.Runtime.InteropServices.ComTypes;
43 #endif
44
45 #if !MOONLIGHT
46 using Mono.Interop;
47 #endif
48
49 namespace System.Runtime.InteropServices
50 {
51 [SuppressUnmanagedCodeSecurity ()]
52 public static class Marshal
53 {
54 /* fields */
55 public static readonly int SystemMaxDBCSCharSize = 2; // don't know what this is
56 public static readonly int SystemDefaultCharSize;
57
58 static Marshal ()
59 {
60 SystemDefaultCharSize = Environment.OSVersion.Platform == PlatformID.Win32NT ? 2 : 1;
61 }
62
63 [MethodImplAttribute (MethodImplOptions.InternalCall)]
64 private extern static int AddRefInternal (IntPtr pUnk);
65
66 public static int AddRef (IntPtr pUnk)
67 {
68 if (pUnk == IntPtr.Zero)
69 throw new ArgumentException ("Value cannot be null.", "pUnk");
70 return AddRefInternal (pUnk);
71 }
72
73 [MethodImplAttribute(MethodImplOptions.InternalCall)]
74 public extern static IntPtr AllocCoTaskMem (int cb);
75
76 [MethodImplAttribute(MethodImplOptions.InternalCall)]
77 [ReliabilityContractAttribute (Consistency.WillNotCorruptState, Cer.MayFail)]
78 public extern static IntPtr AllocHGlobal (IntPtr cb);
79
80 [ReliabilityContractAttribute (Consistency.WillNotCorruptState, Cer.MayFail)]
81 public static IntPtr AllocHGlobal (int cb)
82 {
83 return AllocHGlobal ((IntPtr)cb);
84 }
85
86 [MonoTODO]
87 public static object BindToMoniker (string monikerName)
88 {
89 throw new NotImplementedException ();
90 }
91
92 [MonoTODO]
93 public static void ChangeWrapperHandleStrength (object otp, bool fIsWeak)
94 {
95 throw new NotImplementedException ();
96 }
97
98 [MethodImplAttribute(MethodImplOptions.InternalCall)]
99 internal extern static void copy_to_unmanaged (Array source, int startIndex,
100 IntPtr destination, int length);
101
102 [MethodImplAttribute(MethodImplOptions.InternalCall)]
103 internal extern static void copy_from_unmanaged (IntPtr source, int startIndex,
104 Array destination, int length);
105
106 public static void Copy (byte[] source, int startIndex, IntPtr destination, int length)
107 {
108 copy_to_unmanaged (source, startIndex, destination, length);
109 }
110
111 public static void Copy (char[] source, int startIndex, IntPtr destination, int length)
112 {
113 copy_to_unmanaged (source, startIndex, destination, length);
114 }
115
116 public static void Copy (short[] source, int startIndex, IntPtr destination, int length)
117 {
118 copy_to_unmanaged (source, startIndex, destination, length);
119 }
120
121 public static void Copy (int[] source, int startIndex, IntPtr destination, int length)
122 {
123 copy_to_unmanaged (source, startIndex, destination, length);
124 }
125
126 public static void Copy (long[] source, int startIndex, IntPtr destination, int length)
127 {
128 copy_to_unmanaged (source, startIndex, destination, length);
129 }
130
131 public static void Copy (float[] source, int startIndex, IntPtr destination, int length)
132 {
133 copy_to_unmanaged (source, startIndex, destination, length);
134 }
135
136 public static void Copy (double[] source, int startIndex, IntPtr destination, int length)
137 {
138 copy_to_unmanaged (source, startIndex, destination, length);
139 }
140
141 public static void Copy (IntPtr[] source, int startIndex, IntPtr destination, int length)
142 {
143 copy_to_unmanaged (source, startIndex, destination, length);
144 }
145
146 public static void Copy (IntPtr source, byte[] destination, int startIndex, int length)
147 {
148 copy_from_unmanaged (source, startIndex, destination, length);
149 }
150
151 public static void Copy (IntPtr source, char[] destination, int startIndex, int length)
152 {
153 copy_from_unmanaged (source, startIndex, destination, length);
154 }
155
156 public static void Copy (IntPtr source, short[] destination, int startIndex, int length)
157 {
158 copy_from_unmanaged (source, startIndex, destination, length);
159 }
160
161 public static void Copy (IntPtr source, int[] destination, int startIndex, int length)
162 {
163 copy_from_unmanaged (source, startIndex, destination, length);
164 }
165
166 public static void Copy (IntPtr source, long[] destination, int startIndex, int length)
167 {
168 copy_from_unmanaged (source, startIndex, destination, length);
169 }
170
171 public static void Copy (IntPtr source, float[] destination, int startIndex, int length)
172 {
173 copy_from_unmanaged (source, startIndex, destination, length);
174 }
175
176 public static void Copy (IntPtr source, double[] destination, int startIndex, int length)
177 {
178 copy_from_unmanaged (source, startIndex, destination, length);
179 }
180
181 public static void Copy (IntPtr source, IntPtr[] destination, int startIndex, int length)
182 {
183 copy_from_unmanaged (source, startIndex, destination, length);
184 }
185
186 public static IntPtr CreateAggregatedObject (IntPtr pOuter,
187 object o)
188 {
189 throw new NotImplementedException ();
190 }
191
192 #if !MOONLIGHT
193 public static object CreateWrapperOfType (object o, Type t)
194 {
195 __ComObject co = o as __ComObject;
196 if (co == null)
197 throw new ArgumentException ("o must derive from __ComObject", "o");
198 if (t == null)
199 throw new ArgumentNullException ("t");
200
201 Type[] itfs = o.GetType ().GetInterfaces ();
202 foreach (Type itf in itfs) {
203 if (itf.IsImport && co.GetInterface (itf) == IntPtr.Zero)
204 throw new InvalidCastException ();
205 }
206
207 return ComInteropProxy.GetProxy (co.IUnknown, t).GetTransparentProxy ();
208 }
209 #endif
210
211 [MethodImplAttribute(MethodImplOptions.InternalCall)]
212 [ComVisible (true)]
213 public extern static void DestroyStructure (IntPtr ptr, Type structuretype);
214
215 [MethodImplAttribute(MethodImplOptions.InternalCall)]
216 public extern static void FreeBSTR (IntPtr ptr);
217
218 [MethodImplAttribute(MethodImplOptions.InternalCall)]
219 public extern static void FreeCoTaskMem (IntPtr ptr);
220
221 [MethodImplAttribute(MethodImplOptions.InternalCall)]
222 [ReliabilityContractAttribute (Consistency.WillNotCorruptState, Cer.Success)]
223 public extern static void FreeHGlobal (IntPtr hglobal);
224
225 static void ClearBSTR (IntPtr ptr)
226 {
227 int len = ReadInt32 (ptr, -4);
228
229 for (int i = 0; i < len; i++)
230 WriteByte (ptr, i, 0);
231 }
232
233 public static void ZeroFreeBSTR (IntPtr s)
234 {
235 ClearBSTR (s);
236 FreeBSTR (s);
237 }
238
239 static void ClearAnsi (IntPtr ptr)
240 {
241 for (int i = 0; ReadByte (ptr, i) != 0; i++)
242 WriteByte (ptr, i, 0);
243 }
244
245 static void ClearUnicode (IntPtr ptr)
246 {
247 for (int i = 0; ReadInt16 (ptr, i) != 0; i += 2)
248 WriteInt16 (ptr, i, 0);
249 }
250
251 public static void ZeroFreeCoTaskMemAnsi (IntPtr s)
252 {
253 ClearAnsi (s);
254 FreeCoTaskMem (s);
255 }
256
257 public static void ZeroFreeCoTaskMemUnicode (IntPtr s)
258 {
259 ClearUnicode (s);
260 FreeCoTaskMem (s);
261 }
262
263 public static void ZeroFreeGlobalAllocAnsi (IntPtr s)
264 {
265 ClearAnsi (s);
266 FreeHGlobal (s);
267 }
268
269 public static void ZeroFreeGlobalAllocUnicode (IntPtr s)
270 {
271 ClearUnicode (s);
272 FreeHGlobal (s);
273 }
274
275 #if !MOONLIGHT
276 public static Guid GenerateGuidForType (Type type)
277 {
278 return type.GUID;
279 }
280
281 [MonoTODO]
282 public static string GenerateProgIdForType (Type type)
283 {
284 throw new NotImplementedException ();
285 }
286
287 [MonoTODO]
288 public static object GetActiveObject (string progID)
289 {
290 throw new NotImplementedException ();
291 }
292
293 [MethodImplAttribute (MethodImplOptions.InternalCall)]
294 private extern static IntPtr GetCCW (object o, Type T);
295
296 private static IntPtr GetComInterfaceForObjectInternal (object o, Type T)
297 {
298 if (IsComObject (o))
299 return ((__ComObject)o).GetInterface (T);
300 else
301 return GetCCW (o, T);
302 }
303
304 public static IntPtr GetComInterfaceForObject (object o, Type T)
305 {
306 IntPtr pItf = GetComInterfaceForObjectInternal (o, T);
307 AddRef (pItf);
308 return pItf;
309 }
310
311 [MonoTODO]
312 public static IntPtr GetComInterfaceForObjectInContext (object o, Type t)
313 {
314 throw new NotImplementedException ();
315 }
316
317 [MonoNotSupportedAttribute ("MSDN states user code should never need to call this method.")]
318 public static object GetComObjectData (object obj, object key)
319 {
320 throw new NotSupportedException ("MSDN states user code should never need to call this method.");
321 }
322
323 [MethodImplAttribute(MethodImplOptions.InternalCall)]
324 private extern static int GetComSlotForMethodInfoInternal (MemberInfo m);
325
326 public static int GetComSlotForMethodInfo (MemberInfo m)
327 {
328 if (m == null)
329 throw new ArgumentNullException ("m");
330 if (!(m is MethodInfo))
331 throw new ArgumentException ("The MemberInfo must be an interface method.", "m");
332 if (!m.DeclaringType.IsInterface)
333 throw new ArgumentException ("The MemberInfo must be an interface method.", "m");
334 return GetComSlotForMethodInfoInternal (m);
335 }
336
337 [MonoTODO]
338 public static int GetEndComSlot (Type t)
339 {
340 throw new NotImplementedException ();
341 }
342
343 [MonoTODO]
344 public static int GetExceptionCode()
345 {
346 throw new NotImplementedException ();
347 }
348
349 [MonoTODO]
350 [ComVisible (true)]
351 public static IntPtr GetExceptionPointers()
352 {
353 throw new NotImplementedException ();
354 }
355
356 public static IntPtr GetHINSTANCE (Module m)
357 {
358 if (m == null)
359 throw new ArgumentNullException ("m");
360
361 return m.GetHINSTANCE ();
362 }
363 #endif // !NET_2_1
364
365 [MonoTODO ("SetErrorInfo")]
366 public static int GetHRForException (Exception e)
367 {
368 return e.hresult;
369 }
370
371 [MonoTODO]
372 [ReliabilityContract (Consistency.WillNotCorruptState, Cer.Success)]
373 public static int GetHRForLastWin32Error()
374 {
375 throw new NotImplementedException ();
376 }
377 #if !MOONLIGHT
378 [MethodImplAttribute (MethodImplOptions.InternalCall)]
379 private extern static IntPtr GetIDispatchForObjectInternal (object o);
380
381 public static IntPtr GetIDispatchForObject (object o)
382 {
383 IntPtr pUnk = GetIDispatchForObjectInternal (o);
384 // Internal method does not AddRef
385 AddRef (pUnk);
386 return pUnk;
387 }
388
389 [MonoTODO]
390 public static IntPtr GetIDispatchForObjectInContext (object o)
391 {
392 throw new NotImplementedException ();
393 }
394
395 [MonoTODO]
396 public static IntPtr GetITypeInfoForType (Type t)
397 {
398 throw new NotImplementedException ();
399 }
400
401 [MethodImplAttribute (MethodImplOptions.InternalCall)]
402 private extern static IntPtr GetIUnknownForObjectInternal (object o);
403
404 public static IntPtr GetIUnknownForObject (object o)
405 {
406 IntPtr pUnk = GetIUnknownForObjectInternal (o);
407 // Internal method does not AddRef
408 AddRef (pUnk);
409 return pUnk;
410 }
411
412 [MonoTODO]
413 public static IntPtr GetIUnknownForObjectInContext (object o)
414 {
415 throw new NotImplementedException ();
416 }
417
418 [MonoTODO]
419 [Obsolete ("This method has been deprecated")]
420 public static IntPtr GetManagedThunkForUnmanagedMethodPtr (IntPtr pfnMethodToWrap, IntPtr pbSignature, int cbSignature)
421 {
422 throw new NotImplementedException ();
423 }
424
425 [MonoTODO]
426 public static MemberInfo GetMethodInfoForComSlot (Type t, int slot, ref ComMemberType memberType)
427 {
428 throw new NotImplementedException ();
429 }
430
431 public static void GetNativeVariantForObject (object obj, IntPtr pDstNativeVariant)
432 {
433 Variant vt = new Variant();
434 vt.SetValue(obj);
435 Marshal.StructureToPtr(vt, pDstNativeVariant, false);
436 }
437
438 [MethodImplAttribute (MethodImplOptions.InternalCall)]
439 private static extern object GetObjectForCCW (IntPtr pUnk);
440
441 public static object GetObjectForIUnknown (IntPtr pUnk)
442 {
443 object obj = GetObjectForCCW (pUnk);
444 // was not a CCW
445 if (obj == null) {
446 ComInteropProxy proxy = ComInteropProxy.GetProxy (pUnk, typeof (__ComObject));
447 obj = proxy.GetTransparentProxy ();
448 }
449 return obj;
450 }
451
452 public static object GetObjectForNativeVariant (IntPtr pSrcNativeVariant)
453 {
454 Variant vt = (Variant)Marshal.PtrToStructure(pSrcNativeVariant, typeof(Variant));
455 return vt.GetValue();
456 }
457
458 public static object[] GetObjectsForNativeVariants (IntPtr aSrcNativeVariant, int cVars)
459 {
460 if (cVars < 0)
461 throw new ArgumentOutOfRangeException ("cVars", "cVars cannot be a negative number.");
462 object[] objects = new object[cVars];
463 for (int i = 0; i < cVars; i++)
464 objects[i] = GetObjectForNativeVariant ((IntPtr)(aSrcNativeVariant.ToInt64 () +
465 i * SizeOf (typeof(Variant))));
466 return objects;
467 }
468
469 [MonoTODO]
470 public static int GetStartComSlot (Type t)
471 {
472 throw new NotImplementedException ();
473 }
474
475 [MonoTODO]
476 [Obsolete ("This method has been deprecated")]
477 public static Thread GetThreadFromFiberCookie (int cookie)
478 {
479 throw new NotImplementedException ();
480 }
481
482 public static object GetTypedObjectForIUnknown (IntPtr pUnk, Type t)
483 {
484 ComInteropProxy proxy = new ComInteropProxy (pUnk, t);
485 __ComObject co = (__ComObject)proxy.GetTransparentProxy ();
486 foreach (Type itf in t.GetInterfaces ()) {
487 if ((itf.Attributes & TypeAttributes.Import) == TypeAttributes.Import) {
488 if (co.GetInterface (itf) == IntPtr.Zero)
489 return null;
490 }
491 }
492 return co;
493 }
494
495 [MonoTODO]
496 public static Type GetTypeForITypeInfo (IntPtr piTypeInfo)
497 {
498 throw new NotImplementedException ();
499 }
500
501 [Obsolete]
502 [MonoTODO]
503 public static string GetTypeInfoName (UCOMITypeInfo pTI)
504 {
505 throw new NotImplementedException ();
506 }
507
508 public static string GetTypeInfoName (ITypeInfo typeInfo)
509 {
510 throw new NotImplementedException ();
511 }
512
513 [Obsolete]
514 [MonoTODO]
515 public static Guid GetTypeLibGuid (UCOMITypeLib pTLB)
516 {
517 throw new NotImplementedException ();
518 }
519
520 [MonoTODO]
521 public static Guid GetTypeLibGuid (ITypeLib typelib)
522 {
523 throw new NotImplementedException ();
524 }
525
526 [MonoTODO]
527 public static Guid GetTypeLibGuidForAssembly (Assembly asm)
528 {
529 throw new NotImplementedException ();
530 }
531
532 [Obsolete]
533 [MonoTODO]
534 public static int GetTypeLibLcid (UCOMITypeLib pTLB)
535 {
536 throw new NotImplementedException ();
537 }
538
539 [MonoTODO]
540 public static int GetTypeLibLcid (ITypeLib typelib)
541 {
542 throw new NotImplementedException ();
543 }
544
545 [Obsolete]
546 [MonoTODO]
547 public static string GetTypeLibName (UCOMITypeLib pTLB)
548 {
549 throw new NotImplementedException ();
550 }
551
552 [MonoTODO]
553 public static string GetTypeLibName (ITypeLib typelib)
554 {
555 throw new NotImplementedException ();
556 }
557
558 [MonoTODO]
559 public static void GetTypeLibVersionForAssembly (Assembly inputAssembly, out int majorVersion, out int minorVersion)
560 {
561 throw new NotImplementedException ();
562 }
563
564 public static object GetUniqueObjectForIUnknown (IntPtr unknown)
565 {
566 throw new NotImplementedException ();
567 }
568
569 [MonoTODO]
570 [Obsolete ("This method has been deprecated")]
571 public static IntPtr GetUnmanagedThunkForManagedMethodPtr (IntPtr pfnMethodToWrap, IntPtr pbSignature, int cbSignature)
572 {
573 throw new NotImplementedException ();
574 }
575
576 [MethodImplAttribute (MethodImplOptions.InternalCall)]
577 public extern static bool IsComObject (object o);
578
579 [MonoTODO]
580 public static bool IsTypeVisibleFromCom (Type t)
581 {
582 throw new NotImplementedException ();
583 }
584
585 [MonoTODO]
586 public static int NumParamBytes (MethodInfo m)
587 {
588 throw new NotImplementedException ();
589 }
590 #endif // !NET_2_1
591
592 [MethodImplAttribute(MethodImplOptions.InternalCall)]
593 [ReliabilityContractAttribute (Consistency.WillNotCorruptState, Cer.Success)]
594 public static extern int GetLastWin32Error();
595
596 [MethodImplAttribute(MethodImplOptions.InternalCall)]
597 public extern static IntPtr OffsetOf (Type t, string fieldName);
598
599 [MethodImplAttribute(MethodImplOptions.InternalCall)]
600 public extern static void Prelink (MethodInfo m);
601
602 [MethodImplAttribute(MethodImplOptions.InternalCall)]
603 public extern static void PrelinkAll (Type c);
604
605 [MethodImplAttribute(MethodImplOptions.InternalCall)]
606 public extern static string PtrToStringAnsi (IntPtr ptr);
607
608 [MethodImplAttribute(MethodImplOptions.InternalCall)]
609 public extern static string PtrToStringAnsi (IntPtr ptr, int len);
610
611 public static string PtrToStringAuto (IntPtr ptr)
612 {
613 return SystemDefaultCharSize == 2
614 ? PtrToStringUni (ptr) : PtrToStringAnsi (ptr);
615 }
616
617 public static string PtrToStringAuto (IntPtr ptr, int len)
618 {
619 return SystemDefaultCharSize == 2
620 ? PtrToStringUni (ptr, len) : PtrToStringAnsi (ptr, len);
621 }
622
623 [MethodImplAttribute(MethodImplOptions.InternalCall)]
624 public extern static string PtrToStringUni (IntPtr ptr);
625
626 [MethodImplAttribute(MethodImplOptions.InternalCall)]
627 public extern static string PtrToStringUni (IntPtr ptr, int len);
628
629 [MethodImplAttribute(MethodImplOptions.InternalCall)]
630 public extern static string PtrToStringBSTR (IntPtr ptr);
631
632 [MethodImplAttribute(MethodImplOptions.InternalCall)]
633 [ComVisible (true)]
634 public extern static void PtrToStructure (IntPtr ptr, object structure);
635
636 [MethodImplAttribute(MethodImplOptions.InternalCall)]
637 [ComVisible (true)]
638 public extern static object PtrToStructure (IntPtr ptr, Type structureType);
639
640 [MethodImplAttribute (MethodImplOptions.InternalCall)]
641 private extern static int QueryInterfaceInternal (IntPtr pUnk, ref Guid iid, out IntPtr ppv);
642
643 public static int QueryInterface (IntPtr pUnk, ref Guid iid, out IntPtr ppv)
644 {
645 if (pUnk == IntPtr.Zero)
646 throw new ArgumentException ("Value cannot be null.", "pUnk");
647 return QueryInterfaceInternal (pUnk, ref iid, out ppv);
648 }
649
650 public static byte ReadByte (IntPtr ptr)
651 {
652 return ReadByte (ptr, 0);
653 }
654
655 [MethodImplAttribute(MethodImplOptions.InternalCall)]
656 public extern static byte ReadByte (IntPtr ptr, int ofs);
657
658 [MonoTODO]
659 public static byte ReadByte ([In, MarshalAs (UnmanagedType.AsAny)] object ptr, int ofs)
660 {
661 throw new NotImplementedException ();
662 }
663
664 public static short ReadInt16 (IntPtr ptr)
665 {
666 return ReadInt16 (ptr, 0);
667 }
668
669 [MethodImplAttribute(MethodImplOptions.InternalCall)]
670 public extern static short ReadInt16 (IntPtr ptr, int ofs);
671
672 [MonoTODO]
673 public static short ReadInt16 ([In, MarshalAs(UnmanagedType.AsAny)] object ptr, int ofs)
674 {
675 throw new NotImplementedException ();
676 }
677
678 [ReliabilityContractAttribute (Consistency.WillNotCorruptState, Cer.Success)]
679 public static int ReadInt32 (IntPtr ptr)
680 {
681 return ReadInt32 (ptr, 0);
682 }
683
684 [ReliabilityContractAttribute (Consistency.WillNotCorruptState, Cer.Success)]
685 [MethodImplAttribute(MethodImplOptions.InternalCall)]
686 public extern static int ReadInt32 (IntPtr ptr, int ofs);
687
688 [ReliabilityContractAttribute (Consistency.WillNotCorruptState, Cer.Success)]
689 [MonoTODO]
690 public static int ReadInt32 ([In, MarshalAs(UnmanagedType.AsAny)] object ptr, int ofs)
691 {
692 throw new NotImplementedException ();
693 }
694
695 [ReliabilityContractAttribute (Consistency.WillNotCorruptState, Cer.Success)]
696 public static long ReadInt64 (IntPtr ptr)
697 {
698 return ReadInt64 (ptr, 0);
699 }
700
701 [ReliabilityContractAttribute (Consistency.WillNotCorruptState, Cer.Success)]
702 [MethodImplAttribute(MethodImplOptions.InternalCall)]
703 public extern static long ReadInt64 (IntPtr ptr, int ofs);
704
705 [ReliabilityContractAttribute (Consistency.WillNotCorruptState, Cer.Success)]
706 [MonoTODO]
707 public static long ReadInt64 ([In, MarshalAs (UnmanagedType.AsAny)] object ptr, int ofs)
708 {
709 throw new NotImplementedException ();
710 }
711
712 [ReliabilityContractAttribute (Consistency.WillNotCorruptState, Cer.Success)]
713 public static IntPtr ReadIntPtr (IntPtr ptr)
714 {
715 return ReadIntPtr (ptr, 0);
716 }
717
718 [ReliabilityContractAttribute (Consistency.WillNotCorruptState, Cer.Success)]
719 [MethodImplAttribute(MethodImplOptions.InternalCall)]
720 public extern static IntPtr ReadIntPtr (IntPtr ptr, int ofs);
721
722 [ReliabilityContractAttribute (Consistency.WillNotCorruptState, Cer.Success)]
723 [MonoTODO]
724 public static IntPtr ReadIntPtr ([In, MarshalAs (UnmanagedType.AsAny)] object ptr, int ofs)
725 {
726 throw new NotImplementedException ();
727 }
728
729 [MethodImplAttribute (MethodImplOptions.InternalCall)]
730 public extern static IntPtr ReAllocCoTaskMem (IntPtr pv, int cb);
731
732 [MethodImplAttribute(MethodImplOptions.InternalCall)]
733 public extern static IntPtr ReAllocHGlobal (IntPtr pv, IntPtr cb);
734
735 [ReliabilityContractAttribute (Consistency.WillNotCorruptState, Cer.Success)]
736 [MethodImplAttribute (MethodImplOptions.InternalCall)]
737 private extern static int ReleaseInternal (IntPtr pUnk);
738
739 [ReliabilityContract (Consistency.WillNotCorruptState, Cer.Success)]
740 public static int Release (IntPtr pUnk)
741 {
742 if (pUnk == IntPtr.Zero)
743 throw new ArgumentException ("Value cannot be null.", "pUnk");
744 return ReleaseInternal (pUnk);
745 }
746
747 #if !MOONLIGHT
748 [MethodImplAttribute (MethodImplOptions.InternalCall)]
749 private extern static int ReleaseComObjectInternal (object co);
750
751 public static int ReleaseComObject (object o)
752 {
753 if (o == null)
754 throw new ArgumentException ("Value cannot be null.", "o");
755 if (!IsComObject (o))
756 throw new ArgumentException ("Value must be a Com object.", "o");
757 return ReleaseComObjectInternal (o);
758 }
759
760 [Obsolete]
761 [MonoTODO]
762 public static void ReleaseThreadCache()
763 {
764 throw new NotImplementedException ();
765 }
766
767 [MonoNotSupportedAttribute ("MSDN states user code should never need to call this method.")]
768 public static bool SetComObjectData (object obj, object key, object data)
769 {
770 throw new NotSupportedException ("MSDN states user code should never need to call this method.");
771 }
772 #endif // !NET_2_1
773
774 [ComVisible (true)]
775 public static int SizeOf (object structure)
776 {
777 return SizeOf (structure.GetType ());
778 }
779
780 [MethodImplAttribute(MethodImplOptions.InternalCall)]
781 public extern static int SizeOf (Type t);
782
783 [MethodImplAttribute(MethodImplOptions.InternalCall)]
784 public extern static IntPtr StringToBSTR (string s);
785
786 //
787 // I believe this is wrong, because in Mono and in P/Invoke
788 // we treat "Ansi" conversions as UTF-8 conversions, while
789 // this one does not do this
790 //
791 public static IntPtr StringToCoTaskMemAnsi (string s)
792 {
793 int length = s.Length + 1;
794 IntPtr ctm = AllocCoTaskMem (length);
795
796 byte[] asBytes = new byte[length];
797 for (int i = 0; i < s.Length; i++)
798 asBytes[i] = (byte)s[i];
799 asBytes[s.Length] = 0;
800
801 copy_to_unmanaged (asBytes, 0, ctm, length);
802 return ctm;
803 }
804
805 public static IntPtr StringToCoTaskMemAuto (string s)
806 {
807 return SystemDefaultCharSize == 2
808 ? StringToCoTaskMemUni (s) : StringToCoTaskMemAnsi (s);
809 }
810
811 public static IntPtr StringToCoTaskMemUni (string s)
812 {
813 int length = s.Length + 1;
814 IntPtr ctm = AllocCoTaskMem (length * 2);
815
816 char[] asChars = new char[length];
817 s.CopyTo (0, asChars, 0, s.Length);
818 asChars[s.Length] = '\0';
819
820 copy_to_unmanaged (asChars, 0, ctm, length);
821 return ctm;
822 }
823
824 [MethodImplAttribute(MethodImplOptions.InternalCall)]
825 public extern static IntPtr StringToHGlobalAnsi (string s);
826
827 public static IntPtr StringToHGlobalAuto (string s)
828 {
829 return SystemDefaultCharSize == 2
830 ? StringToHGlobalUni (s) : StringToHGlobalAnsi (s);
831 }
832
833 [MethodImplAttribute(MethodImplOptions.InternalCall)]
834 public extern static IntPtr StringToHGlobalUni (string s);
835
836 #if !MOONLIGHT
837 public static IntPtr SecureStringToBSTR (SecureString s)
838 {
839 if (s == null)
840 throw new ArgumentNullException ("s");
841 int len = s.Length;
842 IntPtr ctm = AllocCoTaskMem ((len+1) * 2 + 4);
843 byte [] buffer = null;
844 WriteInt32 (ctm, 0, len*2);
845 try {
846 buffer = s.GetBuffer ();
847
848 for (int i = 0; i < len; i++)
849 WriteInt16 (ctm, 4 + (i * 2), (short) ((buffer [(i*2)] << 8) | (buffer [i*2+1])));
850 WriteInt16 (ctm, 4 + buffer.Length, 0);
851 } finally {
852 if (buffer != null)
853 for (int i = buffer.Length; i > 0; ){
854 i--;
855 buffer [i] = 0;
856 }
857 }
858 return (IntPtr) ((long)ctm + 4);
859 }
860
861 public static IntPtr SecureStringToCoTaskMemAnsi (SecureString s)
862 {
863 if (s == null)
864 throw new ArgumentNullException ("s");
865 int len = s.Length;
866 IntPtr ctm = AllocCoTaskMem (len + 1);
867 byte [] copy = new byte [len+1];
868
869 try {
870 byte [] buffer = s.GetBuffer ();
871 int i = 0, j = 0;
872 for (; i < len; i++, j += 2){
873 copy [i] = buffer [j+1];
874 buffer [j] = 0;
875 buffer [j+1] = 0;
876 }
877 copy [i] = 0;
878 copy_to_unmanaged (copy, 0, ctm, len+1);
879 } finally {
880 // Ensure that we clear the buffer.
881 for (int i = len; i > 0; ){
882 i--;
883 copy [i] = 0;
884 }
885 }
886 return ctm;
887 }
888
889 public static IntPtr SecureStringToCoTaskMemUnicode (SecureString s)
890 {
891 if (s == null)
892 throw new ArgumentNullException ("s");
893 int len = s.Length;
894 IntPtr ctm = AllocCoTaskMem (len * 2 + 2);
895 byte [] buffer = null;
896 try {
897 buffer = s.GetBuffer ();
898 for (int i = 0; i < len; i++)
899 WriteInt16 (ctm, i * 2, (short) ((buffer [(i*2)] << 8) | (buffer [i*2+1])));
900 WriteInt16 (ctm, buffer.Length, 0);
901 } finally {
902 if (buffer != null)
903 for (int i = buffer.Length; i > 0; ){
904 i--;
905 buffer [i] = 0;
906 }
907 }
908 return ctm;
909 }
910
911 public static IntPtr SecureStringToGlobalAllocAnsi (SecureString s)
912 {
913 if (s == null)
914 throw new ArgumentNullException ("s");
915 return SecureStringToCoTaskMemAnsi (s);
916 }
917
918 public static IntPtr SecureStringToGlobalAllocUnicode (SecureString s)
919 {
920 if (s == null)
921 throw new ArgumentNullException ("s");
922 return SecureStringToCoTaskMemUnicode (s);
923 }
924 #endif
925
926 [ReliabilityContractAttribute (Consistency.WillNotCorruptState, Cer.MayFail)]
927 [ComVisible (true)]
928 [MethodImplAttribute(MethodImplOptions.InternalCall)]
929 public extern static void StructureToPtr (object structure, IntPtr ptr, bool fDeleteOld);
930
931 public static void ThrowExceptionForHR (int errorCode) {
932 Exception ex = GetExceptionForHR (errorCode);
933 if (ex != null)
934 throw ex;
935 }
936
937 public static void ThrowExceptionForHR (int errorCode, IntPtr errorInfo) {
938 Exception ex = GetExceptionForHR (errorCode, errorInfo);
939 if (ex != null)
940 throw ex;
941 }
942
943 [MethodImplAttribute(MethodImplOptions.InternalCall)]
944 public extern static IntPtr UnsafeAddrOfPinnedArrayElement (Array arr, int index);
945
946 public static void WriteByte (IntPtr ptr, byte val)
947 {
948 WriteByte (ptr, 0, val);
949 }
950
951 [MethodImplAttribute(MethodImplOptions.InternalCall)]
952 public extern static void WriteByte (IntPtr ptr, int ofs, byte val);
953
954 [MonoTODO]
955 public static void WriteByte ([In, Out, MarshalAs (UnmanagedType.AsAny)] object ptr, int ofs, byte val)
956 {
957 throw new NotImplementedException ();
958 }
959
960 public static void WriteInt16 (IntPtr ptr, short val)
961 {
962 WriteInt16 (ptr, 0, val);
963 }
964
965 [MethodImplAttribute(MethodImplOptions.InternalCall)]
966 public extern static void WriteInt16 (IntPtr ptr, int ofs, short val);
967
968 [MonoTODO]
969 public static void WriteInt16 ([In, Out, MarshalAs (UnmanagedType.AsAny)] object ptr, int ofs, short val)
970 {
971 throw new NotImplementedException ();
972 }
973
974 public static void WriteInt16 (IntPtr ptr, char val)
975 {
976 WriteInt16 (ptr, 0, val);
977 }
978
979 [MonoTODO]
980 [MethodImplAttribute(MethodImplOptions.InternalCall)]
981 public extern static void WriteInt16 (IntPtr ptr, int ofs, char val);
982
983 [MonoTODO]
984 public static void WriteInt16([In, Out] object ptr, int ofs, char val)
985 {
986 throw new NotImplementedException ();
987 }
988
989 public static void WriteInt32 (IntPtr ptr, int val)
990 {
991 WriteInt32 (ptr, 0, val);
992 }
993
994 [MethodImplAttribute(MethodImplOptions.InternalCall)]
995 public extern static void WriteInt32 (IntPtr ptr, int ofs, int val);
996
997 [MonoTODO]
998 public static void WriteInt32([In, Out, MarshalAs(UnmanagedType.AsAny)] object ptr, int ofs, int val)
999 {
1000 throw new NotImplementedException ();
1001 }
1002
1003 public static void WriteInt64 (IntPtr ptr, long val)
1004 {
1005 WriteInt64 (ptr, 0, val);
1006 }
1007
1008 [MethodImplAttribute(MethodImplOptions.InternalCall)]
1009 public extern static void WriteInt64 (IntPtr ptr, int ofs, long val);
1010
1011 [MonoTODO]
1012 public static void WriteInt64 ([In, Out, MarshalAs (UnmanagedType.AsAny)] object ptr, int ofs, long val)
1013 {
1014 throw new NotImplementedException ();
1015 }
1016
1017 public static void WriteIntPtr (IntPtr ptr, IntPtr val)
1018 {
1019 WriteIntPtr (ptr, 0, val);
1020 }
1021
1022 [MethodImplAttribute(MethodImplOptions.InternalCall)]
1023 public extern static void WriteIntPtr (IntPtr ptr, int ofs, IntPtr val);
1024
1025 [MonoTODO]
1026 public static void WriteIntPtr([In, Out, MarshalAs(UnmanagedType.AsAny)] object ptr, int ofs, IntPtr val)
1027 {
1028 throw new NotImplementedException ();
1029 }
1030
1031 public static Exception GetExceptionForHR (int errorCode) {
1032 return GetExceptionForHR (errorCode, IntPtr.Zero);
1033 }
1034
1035 public static Exception GetExceptionForHR (int errorCode, IntPtr errorInfo) {
1036
1037 const int E_OUTOFMEMORY = unchecked ((int)0x8007000EL);
1038 const int E_INVALIDARG = unchecked ((int)0X80070057);
1039
1040 switch (errorCode)
1041 {
1042 case E_OUTOFMEMORY:
1043 return new OutOfMemoryException ();
1044 case E_INVALIDARG:
1045 return new ArgumentException ();
1046 }
1047 if (errorCode < 0)
1048 return new COMException ("", errorCode);
1049 return null;
1050 }
1051
1052 #if !MOONLIGHT
1053 public static int FinalReleaseComObject (object o)
1054 {
1055 while (ReleaseComObject (o) != 0);
1056 return 0;
1057 }
1058 #endif
1059
1060 [MethodImplAttribute(MethodImplOptions.InternalCall)]
1061 private static extern Delegate GetDelegateForFunctionPointerInternal (IntPtr ptr, Type t);
1062
1063 public static Delegate GetDelegateForFunctionPointer (IntPtr ptr, Type t)
1064 {
1065 if (t == null)
1066 throw new ArgumentNullException ("t");
1067 if (!t.IsSubclassOf (typeof (MulticastDelegate)) || (t == typeof (MulticastDelegate)))
1068 throw new ArgumentException ("Type is not a delegate", "t");
1069 if (ptr == IntPtr.Zero)
1070 throw new ArgumentNullException ("ptr");
1071
1072 return GetDelegateForFunctionPointerInternal (ptr, t);
1073 }
1074
1075 [MethodImplAttribute(MethodImplOptions.InternalCall)]
1076 private static extern IntPtr GetFunctionPointerForDelegateInternal (Delegate d);
1077
1078 public static IntPtr GetFunctionPointerForDelegate (Delegate d)
1079 {
1080 if (d == null)
1081 throw new ArgumentNullException ("d");
1082
1083 return GetFunctionPointerForDelegateInternal (d);
1084 }
1085 }
1086 }
git-svn mirror of mcs