Imported Upstream version 4.0.0~alpha1

Former-commit-id: 806294f5ded97629b74c85c09952f2a74fe182d9

external/referencesource/mscorlib/system/intptr.cs

@@ -0,0 +1,330 @@
+// ==++==
+// 
+//   Copyright (c) Microsoft Corporation.  All rights reserved.
+// 
+// ==--==
+/*============================================================
+**
+** Class:  IntPtr
+**
+**
+** Purpose: Platform independent integer
+**
+** 
+===========================================================*/
+
+namespace System {
+    
+    using System;
+    using System.Globalization;
+    using System.Runtime;
+    using System.Runtime.Serialization;
+    using System.Runtime.CompilerServices;
+    using System.Runtime.ConstrainedExecution;
+    using System.Security;
+    using System.Diagnostics.Contracts;
+    
+    [Serializable]
+[System.Runtime.InteropServices.ComVisible(true)]
+    public struct IntPtr : ISerializable
+    {
+        [SecurityCritical]
+        unsafe private void* m_value; // The compiler treats void* closest to uint hence explicit casts are required to preserve int behavior
+                
+        public static readonly IntPtr Zero;
+
+        // fast way to compare IntPtr to (IntPtr)0 while IntPtr.Zero doesn't work due to slow statics access
+        [System.Security.SecuritySafeCritical]  // auto-generated
+        [Pure]
+        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
+        internal unsafe bool IsNull()
+        {
+            return (this.m_value == null);
+        }
+
+        [System.Security.SecuritySafeCritical]  // auto-generated
+        [ReliabilityContract(Consistency.MayCorruptInstance, Cer.MayFail)]
+#if !FEATURE_CORECLR
+        [TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
+#endif
+        public unsafe IntPtr(int value)
+        {
+            #if WIN32
+                m_value = (void *)value;
+            #else
+                m_value = (void *)(long)value;
+            #endif
+        }
+    
+        [System.Security.SecuritySafeCritical]  // auto-generated
+        [ReliabilityContract(Consistency.MayCorruptInstance, Cer.MayFail)]
+#if !FEATURE_CORECLR
+        [TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
+#endif
+        public unsafe IntPtr(long value)
+        {
+            #if WIN32
+                m_value = (void *)checked((int)value);
+            #else
+                m_value = (void *)value;
+            #endif
+        }
+
+        [System.Security.SecurityCritical]
+        [CLSCompliant(false)]
+        [ReliabilityContract(Consistency.MayCorruptInstance, Cer.MayFail)]
+        public unsafe IntPtr(void* value)
+        {
+            m_value = value;
+        }
+
+        [System.Security.SecurityCritical]  // auto-generated
+        private unsafe IntPtr(SerializationInfo info, StreamingContext context) {
+            long l = info.GetInt64("value");
+
+            if (Size==4 && (l>Int32.MaxValue || l<Int32.MinValue)) {
+                throw new ArgumentException(Environment.GetResourceString("Serialization_InvalidPtrValue"));
+            }
+
+            m_value = (void *)l;
+        }
+
+#if FEATURE_SERIALIZATION
+        [System.Security.SecurityCritical]
+        unsafe void ISerializable.GetObjectData(SerializationInfo info, StreamingContext context) {
+            if (info==null) {
+                throw new ArgumentNullException("info");
+            }
+            Contract.EndContractBlock();
+            #if WIN32
+                info.AddValue("value", (long)((int)m_value));
+            #else
+                info.AddValue("value", (long)(m_value));
+            #endif
+        }
+#endif
+
+        [System.Security.SecuritySafeCritical]  // auto-generated
+        public unsafe override bool Equals(Object obj) {
+            if (obj is IntPtr) {
+                return (m_value == ((IntPtr)obj).m_value);
+            }
+            return false;
+        }
+    
+        [System.Security.SecuritySafeCritical]  // auto-generated
+#if !FEATURE_CORECLR
+        [TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
+#endif
+        public unsafe override int GetHashCode() {
+            return unchecked((int)((long)m_value));
+        }
+
+        [System.Security.SecuritySafeCritical]  // auto-generated
+        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
+#if !FEATURE_CORECLR
+        [TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
+#endif
+        public unsafe int ToInt32() {
+            #if WIN32
+                return (int)m_value;
+            #else
+                long l = (long)m_value;
+                return checked((int)l);
+            #endif
+        }
+
+        [System.Security.SecuritySafeCritical]  // auto-generated
+        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
+#if !FEATURE_CORECLR
+        [TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
+#endif
+        public unsafe long ToInt64() {
+            #if WIN32
+                return (long)(int)m_value;
+            #else
+                return (long)m_value;
+            #endif
+        }
+
+        [System.Security.SecuritySafeCritical]  // auto-generated
+        public unsafe override String ToString() {
+            #if WIN32
+                return ((int)m_value).ToString(CultureInfo.InvariantCulture);
+            #else
+                return ((long)m_value).ToString(CultureInfo.InvariantCulture);
+            #endif
+        }
+
+        [System.Security.SecuritySafeCritical]  // auto-generated
+        public unsafe  String ToString(String format) 
+        {
+            Contract.Ensures(Contract.Result<String>() != null);
+
+            #if WIN32
+                return ((int)m_value).ToString(format, CultureInfo.InvariantCulture);
+            #else
+                return ((long)m_value).ToString(format, CultureInfo.InvariantCulture);
+            #endif
+        }
+
+
+        [ReliabilityContract(Consistency.MayCorruptInstance, Cer.MayFail)]
+#if !FEATURE_CORECLR
+        [TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
+#endif
+        public static explicit operator IntPtr (int value) 
+        {
+            return new IntPtr(value);
+        }
+
+        [ReliabilityContract(Consistency.MayCorruptInstance, Cer.MayFail)]
+#if !FEATURE_CORECLR
+        [TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
+#endif
+        public static explicit operator IntPtr (long value) 
+        {
+            return new IntPtr(value);
+        }
+
+        [System.Security.SecurityCritical]
+        [CLSCompliant(false), ReliabilityContract(Consistency.MayCorruptInstance, Cer.MayFail)]
+#if !FEATURE_CORECLR
+        [TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
+#endif
+        public static unsafe explicit operator IntPtr (void* value)
+        {
+            return new IntPtr(value);
+        }
+
+        [System.Security.SecuritySafeCritical]  // auto-generated
+        [CLSCompliant(false)]
+#if !FEATURE_CORECLR
+        [TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
+#endif        
+        public static unsafe explicit operator void* (IntPtr value)
+        {
+            return value.ToPointer();
+        }
+
+        [System.Security.SecuritySafeCritical]  // auto-generated
+#if !FEATURE_CORECLR
+        [TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
+#endif
+        public unsafe static explicit operator int (IntPtr  value) 
+        {
+            #if WIN32
+                return (int)value.m_value;
+            #else
+                long l = (long)value.m_value;
+                return checked((int)l);
+            #endif
+        }
+
+        [System.Security.SecuritySafeCritical]  // auto-generated
+#if !FEATURE_CORECLR
+        [TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
+#endif
+        public unsafe static explicit operator long (IntPtr  value) 
+        {
+            #if WIN32
+                return (long)(int)value.m_value;
+            #else
+                return (long)value.m_value;
+            #endif
+        }
+
+        [System.Security.SecuritySafeCritical]  // auto-generated
+        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
+#if !FEATURE_CORECLR
+        [TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
+#endif
+        public unsafe static bool operator == (IntPtr value1, IntPtr value2) 
+        {
+            return value1.m_value == value2.m_value;
+        }
+
+        [System.Security.SecuritySafeCritical]  // auto-generated
+        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
+#if !FEATURE_CORECLR
+        [TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
+#endif
+        public unsafe static bool operator != (IntPtr value1, IntPtr value2) 
+        {
+            return value1.m_value != value2.m_value;
+        }
+
+        [ReliabilityContract(Consistency.MayCorruptInstance, Cer.MayFail)]
+#if !FEATURE_CORECLR
+        [TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
+#endif
+        public static IntPtr Add(IntPtr pointer, int offset)
+        {
+            return pointer + offset;
+        }
+
+        [ReliabilityContract(Consistency.MayCorruptInstance, Cer.MayFail)]
+#if !FEATURE_CORECLR
+        [TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
+#endif
+        public static IntPtr operator +(IntPtr pointer, int offset) 
+        {
+            #if WIN32
+                return new IntPtr(pointer.ToInt32() + offset);
+            #else
+                return new IntPtr(pointer.ToInt64() + offset);
+            #endif
+        }
+
+        [ReliabilityContract(Consistency.MayCorruptInstance, Cer.MayFail)]
+#if !FEATURE_CORECLR
+        [TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
+#endif
+        public static IntPtr Subtract(IntPtr pointer, int offset) {
+            return pointer - offset;
+        }
+
+        [ReliabilityContract(Consistency.MayCorruptInstance, Cer.MayFail)]
+#if !FEATURE_CORECLR
+        [TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
+#endif
+        public static IntPtr operator -(IntPtr pointer, int offset) {
+            #if WIN32
+                return new IntPtr(pointer.ToInt32() - offset);
+            #else
+                return new IntPtr(pointer.ToInt64() - offset);
+            #endif
+        }
+
+        public static int Size
+        {
+            [Pure]
+            [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
+#if !FEATURE_CORECLR
+            [TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
+#endif
+            get
+            {
+                #if WIN32
+                    return 4;
+                #else
+                    return 8;
+                #endif
+            }
+        }
+    
+
+        [System.Security.SecuritySafeCritical]  // auto-generated
+        [CLSCompliant(false)]
+        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
+#if !FEATURE_CORECLR
+        [TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
+#endif
+        public unsafe void* ToPointer()
+        {
+            return m_value;
+        }
+    }
+}
+
+