Imported Upstream version 2.0.0.11353upstream/2.0.0.11353

1 files changed, 85 insertions, 66 deletions

diff --git a/src/mscorlib/src/System/Int64.cs b/src/mscorlib/src/System/Int64.cs
index 3520ede533..3d64362e30 100644
--- a/src/mscorlib/src/System/Int64.cs
+++ b/src/mscorlib/src/System/Int64.cs
@@ -11,20 +11,21 @@
 **
 ** 
 ===========================================================*/
-namespace System {
-    
-    using System;
-    using System.Globalization;
-    using System.Runtime.InteropServices;
-    using System.Diagnostics.Contracts;
-
-[Serializable]
-[System.Runtime.InteropServices.StructLayout(LayoutKind.Sequential)]
+
+using System;
+using System.Globalization;
+using System.Runtime.InteropServices;
+using System.Diagnostics.Contracts;
+
+namespace System
+{
+    [Serializable]
+    [System.Runtime.InteropServices.StructLayout(LayoutKind.Sequential)]
     public struct Int64 : IComparable, IFormattable, IConvertible
-        , IComparable<Int64>, IEquatable<Int64>
+            , IComparable<Int64>, IEquatable<Int64>
     {
         internal long m_value;
-    
+
         public const long MaxValue = 0x7fffffffffffffffL;
         public const long MinValue = unchecked((long)0x8000000000000000L);
 
@@ -34,11 +35,14 @@ namespace System {
         // null is considered to be less than any instance.
         // If object is not of type Int64, this method throws an ArgumentException.
         // 
-        public int CompareTo(Object value) {
-            if (value == null) {
+        public int CompareTo(Object value)
+        {
+            if (value == null)
+            {
                 return 1;
             }
-            if (value is Int64) {
+            if (value is Int64)
+            {
                 // Need to use compare because subtraction will wrap
                 // to positive for very large neg numbers, etc.
                 long i = (long)value;
@@ -46,19 +50,22 @@ namespace System {
                 if (m_value > i) return 1;
                 return 0;
             }
-            throw new ArgumentException (Environment.GetResourceString("Arg_MustBeInt64"));
+            throw new ArgumentException(SR.Arg_MustBeInt64);
         }
 
-        public int CompareTo(Int64 value) {
+        public int CompareTo(Int64 value)
+        {
             // Need to use compare because subtraction will wrap
             // to positive for very large neg numbers, etc.
             if (m_value < value) return -1;
             if (m_value > value) return 1;
             return 0;
         }
-    
-        public override bool Equals(Object obj) {
-            if (!(obj is Int64)) {
+
+        public override bool Equals(Object obj)
+        {
+            if (!(obj is Int64))
+            {
                 return false;
             }
             return m_value == ((Int64)obj).m_value;
@@ -71,40 +78,48 @@ namespace System {
         }
 
         // The value of the lower 32 bits XORed with the uppper 32 bits.
-        public override int GetHashCode() {
+        public override int GetHashCode()
+        {
             return (unchecked((int)((long)m_value)) ^ (int)(m_value >> 32));
         }
 
-        public override String ToString() {
+        public override String ToString()
+        {
             Contract.Ensures(Contract.Result<String>() != null);
             return Number.FormatInt64(m_value, null, NumberFormatInfo.CurrentInfo);
         }
-    
-        public String ToString(IFormatProvider provider) {
+
+        public String ToString(IFormatProvider provider)
+        {
             Contract.Ensures(Contract.Result<String>() != null);
             return Number.FormatInt64(m_value, null, NumberFormatInfo.GetInstance(provider));
         }
-    
-        public String ToString(String format) {
+
+        public String ToString(String format)
+        {
             Contract.Ensures(Contract.Result<String>() != null);
             return Number.FormatInt64(m_value, format, NumberFormatInfo.CurrentInfo);
         }
 
-        public String ToString(String format, IFormatProvider provider) {
+        public String ToString(String format, IFormatProvider provider)
+        {
             Contract.Ensures(Contract.Result<String>() != null);
             return Number.FormatInt64(m_value, format, NumberFormatInfo.GetInstance(provider));
         }
 
-        public static long Parse(String s) {
+        public static long Parse(String s)
+        {
             return Number.ParseInt64(s, NumberStyles.Integer, NumberFormatInfo.CurrentInfo);
         }
-    
-        public static long Parse(String s, NumberStyles style) {
+
+        public static long Parse(String s, NumberStyles style)
+        {
             NumberFormatInfo.ValidateParseStyleInteger(style);
             return Number.ParseInt64(s, style, NumberFormatInfo.CurrentInfo);
         }
 
-        public static long Parse(String s, IFormatProvider provider) {
+        public static long Parse(String s, IFormatProvider provider)
+        {
             return Number.ParseInt64(s, NumberStyles.Integer, NumberFormatInfo.GetInstance(provider));
         }
 
@@ -113,16 +128,19 @@ namespace System {
         // a NumberFormatInfo isn't specified, the current culture's 
         // NumberFormatInfo is assumed.
         // 
-        public static long Parse(String s, NumberStyles style, IFormatProvider provider) {
+        public static long Parse(String s, NumberStyles style, IFormatProvider provider)
+        {
             NumberFormatInfo.ValidateParseStyleInteger(style);
             return Number.ParseInt64(s, style, NumberFormatInfo.GetInstance(provider));
         }
 
-        public static Boolean TryParse(String s, out Int64 result) {
+        public static Boolean TryParse(String s, out Int64 result)
+        {
             return Number.TryParseInt64(s, NumberStyles.Integer, NumberFormatInfo.CurrentInfo, out result);
         }
 
-        public static Boolean TryParse(String s, NumberStyles style, IFormatProvider provider, out Int64 result) {
+        public static Boolean TryParse(String s, NumberStyles style, IFormatProvider provider, out Int64 result)
+        {
             NumberFormatInfo.ValidateParseStyleInteger(style);
             return Number.TryParseInt64(s, style, NumberFormatInfo.GetInstance(provider), out result);
         }
@@ -130,83 +148,84 @@ namespace System {
         //
         // IConvertible implementation
         // 
-        
-        public TypeCode GetTypeCode() {
+
+        public TypeCode GetTypeCode()
+        {
             return TypeCode.Int64;
         }
 
-        /// <internalonly/>
-        bool IConvertible.ToBoolean(IFormatProvider provider) {
+        bool IConvertible.ToBoolean(IFormatProvider provider)
+        {
             return Convert.ToBoolean(m_value);
         }
 
-        /// <internalonly/>
-        char IConvertible.ToChar(IFormatProvider provider) {
+        char IConvertible.ToChar(IFormatProvider provider)
+        {
             return Convert.ToChar(m_value);
         }
 
-        /// <internalonly/>
-        sbyte IConvertible.ToSByte(IFormatProvider provider) {
+        sbyte IConvertible.ToSByte(IFormatProvider provider)
+        {
             return Convert.ToSByte(m_value);
         }
 
-        /// <internalonly/>
-        byte IConvertible.ToByte(IFormatProvider provider) {
+        byte IConvertible.ToByte(IFormatProvider provider)
+        {
             return Convert.ToByte(m_value);
         }
 
-        /// <internalonly/>
-        short IConvertible.ToInt16(IFormatProvider provider) {
+        short IConvertible.ToInt16(IFormatProvider provider)
+        {
             return Convert.ToInt16(m_value);
         }
 
-        /// <internalonly/>
-        ushort IConvertible.ToUInt16(IFormatProvider provider) {
+        ushort IConvertible.ToUInt16(IFormatProvider provider)
+        {
             return Convert.ToUInt16(m_value);
         }
 
-        /// <internalonly/>
-        int IConvertible.ToInt32(IFormatProvider provider) {
+        int IConvertible.ToInt32(IFormatProvider provider)
+        {
             return Convert.ToInt32(m_value);
         }
 
-        /// <internalonly/>
-        uint IConvertible.ToUInt32(IFormatProvider provider) {
+        uint IConvertible.ToUInt32(IFormatProvider provider)
+        {
             return Convert.ToUInt32(m_value);
         }
 
-        /// <internalonly/>
-        long IConvertible.ToInt64(IFormatProvider provider) {
+        long IConvertible.ToInt64(IFormatProvider provider)
+        {
             return m_value;
         }
 
-        /// <internalonly/>
-        ulong IConvertible.ToUInt64(IFormatProvider provider) {
+        ulong IConvertible.ToUInt64(IFormatProvider provider)
+        {
             return Convert.ToUInt64(m_value);
         }
 
-        /// <internalonly/>
-        float IConvertible.ToSingle(IFormatProvider provider) {
+        float IConvertible.ToSingle(IFormatProvider provider)
+        {
             return Convert.ToSingle(m_value);
         }
 
-        /// <internalonly/>
-        double IConvertible.ToDouble(IFormatProvider provider) {
+        double IConvertible.ToDouble(IFormatProvider provider)
+        {
             return Convert.ToDouble(m_value);
         }
 
-        /// <internalonly/>
-        Decimal IConvertible.ToDecimal(IFormatProvider provider) {
+        Decimal IConvertible.ToDecimal(IFormatProvider provider)
+        {
             return Convert.ToDecimal(m_value);
         }
 
-        /// <internalonly/>
-        DateTime IConvertible.ToDateTime(IFormatProvider provider) {
-            throw new InvalidCastException(Environment.GetResourceString("InvalidCast_FromTo", "Int64", "DateTime"));
+        DateTime IConvertible.ToDateTime(IFormatProvider provider)
+        {
+            throw new InvalidCastException(SR.Format(SR.InvalidCast_FromTo, "Int64", "DateTime"));
         }
 
-        /// <internalonly/>
-        Object IConvertible.ToType(Type type, IFormatProvider provider) {
+        Object IConvertible.ToType(Type type, IFormatProvider provider)
+        {
             return Convert.DefaultToType((IConvertible)this, type, provider);
         }
     }