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 namespace System
  49 {
  50         [Serializable]
  51         public unsafe struct IntPtr : ISerializable
  52         {
  53                 private void *value;
  54
  55                 public static readonly IntPtr Zero;
  56
  57                 public IntPtr (int i32)
  58                 {
  59                         value = (void *) i32;
  60                 }
  61
  62                 public IntPtr (long i64)
  63                 {
  64                         if (((i64 > Int32.MaxValue) || (i64 < Int32.MinValue)) && (IntPtr.Size < 8)) {
  65                                 throw new OverflowException (
  66                                         Locale.GetText ("This isn't a 64bits machine."));
  67                         }
  68
  69                         value = (void *) i64;
  70                 }
  71
  72                 [CLSCompliant (false)]
  73                 unsafe public IntPtr (void *ptr)
  74                 {
  75                         value = ptr;
  76                 }
  77
  78                 private IntPtr (SerializationInfo info, StreamingContext context)
  79                 {
  80                         long savedValue = info.GetInt64 ("value");
  81                         value = (void *) savedValue;
  82                 }
  83
  84                 public static int Size {
  85                         get {
  86                                 return sizeof (void *);
  87                         }
  88                 }
  89
  90                 void ISerializable.GetObjectData (SerializationInfo info, StreamingContext context)
  91                 {
  92                         if (info == null)
  93                                 throw new ArgumentNullException ("info");
  94
  95                         info.AddValue ("value", (long) value);
  96                 }
  97
  98                 public override bool Equals (object o)
  99                 {
 100                         if (!(o is System.IntPtr))
 101                                 return false;
 102
 103                         return ((IntPtr) o).value == value;
 104                 }
 105
 106                 public override int GetHashCode ()
 107                 {
 108                         return (int) value;
 109                 }
 110
 111                 public int ToInt32 ()
 112                 {
 113                         return (int) value;
 114                 }
 115
 116                 public long ToInt64 ()
 117                 {
 118                         return (long) value;
 119                 }
 120
 121                 [CLSCompliant (false)]
 122                 unsafe public void *ToPointer ()
 123                 {
 124                         return value;
 125                 }
 126
 127                 override public string ToString ()
 128                 {
 129                         if (Size == 4)
 130                                 return ((int) value).ToString ();
 131                         else
 132                                 return ((long) value).ToString ();
 133                 }
 134
 135                 public static bool operator == (IntPtr a, IntPtr b)
 136                 {
 137                         return (a.value == b.value);
 138                 }
 139
 140                 public static bool operator != (IntPtr a, IntPtr b)
 141                 {
 142                         return (a.value != b.value);
 143                 }
 144
 145                 public static explicit operator IntPtr (int value)
 146                 {
 147                         return new IntPtr (value);
 148                 }
 149
 150                 public static explicit operator IntPtr (long value)
 151                 {
 152                         return new IntPtr (value);
 153                 }
 154
 155                 [CLSCompliant (false)]
 156                 unsafe public static explicit operator IntPtr (void *value)
 157                 {
 158                         return new IntPtr (value);
 159                 }
 160
 161                 public static explicit operator int (IntPtr value)
 162                 {
 163                         return (int) value.value;
 164                 }
 165
 166                 public static explicit operator long (IntPtr value)
 167                 {
 168                         return (long) value.value;
 169                 }
 170
 171                 [CLSCompliant (false)]
 172                 unsafe public static explicit operator void * (IntPtr value)
 173                 {
 174                         return value.value;
 175                 }
 176         }
 177 }