mcs/class/corlib/System/IntPtr.cs

   1 //
   2 // System.IntPtr.cs
   3 //
   4 // Author:
   5 //   Miguel de Icaza (miguel@ximian.com)
   6 //
   7 // Maintainer:
   8 //       Michael Lambert, michaellambert@email.com
   9 //
  10 // (C) Ximian, Inc.  http://www.ximian.com
  11 //
  12 // Remarks:
  13 //   Requires '/unsafe' compiler option.  This class uses void*,
  14 //   in overloaded constructors, conversion, and cast members in
  15 //   the public interface.  Using pointers is not valid CLS and
  16 //   the methods in question have been marked with  the
  17 //   CLSCompliant attribute that avoid compiler warnings.
  18 //
  19 // FIXME: How do you specify a native int in C#?  I am going to have to do some figuring out
  20 //
  21
  22 //
  23 // Copyright (C) 2004 Novell, Inc (http://www.novell.com)
  24 //
  25 // Permission is hereby granted, free of charge, to any person obtaining
  26 // a copy of this software and associated documentation files (the
  27 // "Software"), to deal in the Software without restriction, including
  28 // without limitation the rights to use, copy, modify, merge, publish,
  29 // distribute, sublicense, and/or sell copies of the Software, and to
  30 // permit persons to whom the Software is furnished to do so, subject to
  31 // the following conditions:
  32 //
  33 // The above copyright notice and this permission notice shall be
  34 // included in all copies or substantial portions of the Software.
  35 //
  36 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  37 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  38 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  39 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  40 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  41 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  42 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  43 //
  44
  45 using System.Globalization;
  46 using System.Runtime.Serialization;
  47
  48 #if NET_2_0
  49 using System.Runtime.ConstrainedExecution;
  50 #endif
  51
  52 namespace System
  53 {
  54         [Serializable]
  55         public unsafe struct IntPtr : ISerializable
  56         {
  57                 private void *value;
  58
  59                 public static readonly IntPtr Zero;
  60
  61                 public IntPtr (int i32)
  62                 {
  63                         value = (void *) i32;
  64                 }
  65
  66                 public IntPtr (long i64)
  67                 {
  68                         if (((i64 > Int32.MaxValue) || (i64 < Int32.MinValue)) && (IntPtr.Size < 8)) {
  69                                 throw new OverflowException (
  70                                         Locale.GetText ("This isn't a 64bits machine."));
  71                         }
  72
  73                         value = (void *) i64;
  74                 }
  75
  76                 [CLSCompliant (false)]
  77                 unsafe public IntPtr (void *ptr)
  78                 {
  79                         value = ptr;
  80                 }
  81
  82                 private IntPtr (SerializationInfo info, StreamingContext context)
  83                 {
  84                         long savedValue = info.GetInt64 ("value");
  85                         value = (void *) savedValue;
  86                 }
  87
  88                 public static int Size {
  89                         get {
  90                                 return sizeof (void *);
  91                         }
  92                 }
  93
  94                 void ISerializable.GetObjectData (SerializationInfo info, StreamingContext context)
  95                 {
  96                         if (info == null)
  97                                 throw new ArgumentNullException ("info");
  98
  99                         info.AddValue ("value", (long) value);
 100                 }
 101
 102                 public override bool Equals (object o)
 103                 {
 104                         if (!(o is System.IntPtr))
 105                                 return false;
 106
 107                         return ((IntPtr) o).value == value;
 108                 }
 109
 110                 public override int GetHashCode ()
 111                 {
 112                         return (int) value;
 113                 }
 114
 115 #if NET_2_0
 116                 [ReliabilityContractAttribute (Consistency.WillNotCorruptState, CER.Success)]
 117 #endif
 118                 public int ToInt32 ()
 119                 {
 120                         return (int) value;
 121                 }
 122
 123 #if NET_2_0
 124                 [ReliabilityContractAttribute (Consistency.WillNotCorruptState, CER.Success)]
 125 #endif
 126                 public long ToInt64 ()
 127                 {
 128                         return (long) value;
 129                 }
 130
 131                 [CLSCompliant (false)]
 132                 unsafe public void *ToPointer ()
 133                 {
 134                         return value;
 135                 }
 136
 137                 override public string ToString ()
 138                 {
 139                         if (Size == 4)
 140                                 return ((int) value).ToString ();
 141                         else
 142                                 return ((long) value).ToString ();
 143                 }
 144
 145 #if NET_2_0
 146                 [ReliabilityContractAttribute (Consistency.WillNotCorruptState, CER.Success)]
 147 #endif
 148                 public static bool operator == (IntPtr a, IntPtr b)
 149                 {
 150                         return (a.value == b.value);
 151                 }
 152
 153 #if NET_2_0
 154                 [ReliabilityContractAttribute (Consistency.WillNotCorruptState, CER.Success)]
 155 #endif
 156                 public static bool operator != (IntPtr a, IntPtr b)
 157                 {
 158                         return (a.value != b.value);
 159                 }
 160
 161 #if NET_2_0
 162                 [ReliabilityContractAttribute (Consistency.WillNotCorruptState, CER.Success)]
 163 #endif
 164                 public static explicit operator IntPtr (int value)
 165                 {
 166                         return new IntPtr (value);
 167                 }
 168
 169 #if NET_2_0
 170                 [ReliabilityContractAttribute (Consistency.WillNotCorruptState, CER.Success)]
 171 #endif
 172                 public static explicit operator IntPtr (long value)
 173                 {
 174                         return new IntPtr (value);
 175                 }
 176
 177 #if NET_2_0
 178                 [ReliabilityContractAttribute (Consistency.WillNotCorruptState, CER.Success)]
 179 #endif
 180                 [CLSCompliant (false)]
 181                 unsafe public static explicit operator IntPtr (void *value)
 182                 {
 183                         return new IntPtr (value);
 184                 }
 185
 186                 public static explicit operator int (IntPtr value)
 187                 {
 188                         return (int) value.value;
 189                 }
 190
 191                 public static explicit operator long (IntPtr value)
 192                 {
 193                         return (long) value.value;
 194                 }
 195
 196                 [CLSCompliant (false)]
 197                 unsafe public static explicit operator void * (IntPtr value)
 198                 {
 199                         return value.value;
 200                 }
 201         }
 202 }