path: root/mcs/class/corlib/System/Decimal.cs

//
// System.Decimal.cs
//
// Represents a floating-point decimal data type with up to 29 
// significant digits, suitable for financial and commercial calculations.
//
// Authors:
//   Martin Weindel (martin.weindel@t-online.de)
//   Marek Safar (marek.safar@gmail.com)
//
// (C) 2001 Martin Weindel
// Copyright (C) 2004 Novell, Inc (http://www.novell.com)
// Copyright (C) 2014 Xamarin Inc (http://www.xamarin.com)
//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
// 
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
// 
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//

using System;
using System.Globalization;
using System.Text;
using System.Runtime.CompilerServices;
using System.Runtime.ConstrainedExecution;
using System.Runtime.Serialization;

#if MSTEST
using System.Runtime.InteropServices;
#endif


namespace System
{
	/// <summary>
	/// Represents a floating-point decimal data type with up to 29 significant
	/// digits, suitable for financial and commercial calculations
	/// </summary>
	[Serializable]
	[System.Runtime.InteropServices.ComVisible (true)]
	public struct Decimal: IFormattable, IConvertible, IComparable, IComparable<Decimal>, IEquatable <Decimal>
		, IDeserializationCallback
	{
		public const decimal MinValue = -79228162514264337593543950335m;
		public const decimal MaxValue =  79228162514264337593543950335m;

		public const decimal MinusOne = -1;
		public const decimal One = 1;
		public const decimal Zero = 0;

		private static readonly Decimal MaxValueDiv10 = MaxValue / 10;

		// some constants
		private const uint MAX_SCALE = 28;
		private const uint SIGN_FLAG = 0x80000000;
		private const int SCALE_SHIFT = 16;
		private const uint RESERVED_SS32_BITS = 0x7F00FFFF;

		// internal representation of decimal
		private uint flags;
		private uint hi;
		private uint lo;
		private uint mid;

		public Decimal (int lo, int mid, int hi, bool isNegative, byte scale)
		{
			unchecked 
			{
				this.lo = (uint) lo;
				this.mid = (uint) mid;
				this.hi = (uint) hi;

				if (scale > MAX_SCALE) 
					throw new ArgumentOutOfRangeException (Locale.GetText ("scale must be between 0 and 28"));

				flags = scale;
				flags <<= SCALE_SHIFT;
				if (isNegative) flags |= SIGN_FLAG;
			}
		}

		public Decimal (int value) 
		{
			unchecked 
			{
				hi = mid = 0;
				if (value < 0) 
				{
					flags = SIGN_FLAG;
					lo = ((uint)~value) + 1;
				}
				else 
				{
					flags = 0;
					lo = (uint) value;
				}
			}
		}

		[CLSCompliant(false)]
		public Decimal (uint value) 
		{
			lo = value;
			flags = hi = mid = 0;
		}

		public Decimal (long value) 
		{
			unchecked 
			{
				hi = 0;
				if (value < 0) 
				{
					flags = SIGN_FLAG;
					ulong u = ((ulong)~value) + 1;
					lo = (uint)u;
					mid = (uint)(u >> 32);
				}
				else 
				{
					flags = 0;
					ulong u = (ulong)value;
					lo = (uint)u;
					mid = (uint)(u >> 32);
				}
			}
		}

		[CLSCompliant(false)]
		public Decimal (ulong value) 
		{
			unchecked 
			{
				flags = hi = 0;
				lo = (uint)value;
				mid = (uint)(value >> 32);
			}
		}

		public Decimal (float value) 
		{
#if false
			//
			// We cant use the double2decimal method
			// because it incorrectly turns the floating point
			// value 1.23456789E-25F which should be:
			//    0.0000000000000000000000001235
			// into the incorrect:
			//   0.0000000000000000000000001234
			//
			//    The code currently parses the double value 0.6 as
			//    0.600000000000000
			//
			// And we have a patch for that called (trim
			if (double2decimal (out this, value, 7) != 0)
				throw new OverflowException ();
#else
			if (value > (float)Decimal.MaxValue || value < (float)Decimal.MinValue ||
				float.IsNaN (value) || float.IsNegativeInfinity (value) || float.IsPositiveInfinity (value)) {
				throw new OverflowException (Locale.GetText (
					"Value {0} is greater than Decimal.MaxValue or less than Decimal.MinValue", value));
			}
			
			// we must respect the precision (double2decimal doesn't)
			Decimal d = Decimal.Parse (value.ToString (CultureInfo.InvariantCulture),
					NumberStyles.Float, CultureInfo.InvariantCulture);
			flags = d.flags;
			hi = d.hi;
			lo = d.lo;
			mid = d.mid;
#endif
		}

		public Decimal (double value) 
		{
#if true
			//
			// We cant use the double2decimal method
			// because it incorrectly turns the floating point
			// value 1.23456789E-25F which should be:
			//    0.0000000000000000000000001235
			// into the incorrect:
			//   0.0000000000000000000000001234
			//
			//    The code currently parses the double value 0.6 as
			//    0.600000000000000
			//
			// And we have a patch for that called (trim
			if (double2decimal (out this, value, 15) != 0)
				throw new OverflowException ();
#else
			if (value > (double)Decimal.MaxValue || value < (double)Decimal.MinValue ||
				double.IsNaN (value) || double.IsNegativeInfinity (value) || double.IsPositiveInfinity (value)) {
				throw new OverflowException (Locale.GetText (
					"Value {0} is greater than Decimal.MaxValue or less than Decimal.MinValue", value));
			}
			// we must respect the precision (double2decimal doesn't)
			Decimal d = Decimal.Parse (value.ToString (CultureInfo.InvariantCulture),
					NumberStyles.Float, CultureInfo.InvariantCulture);
			flags = d.flags;
			hi = d.hi;
			lo = d.lo;
			mid = d.mid;
#endif
		}

		public Decimal (int[] bits) 
		{
			if (bits == null) 
			{
				throw new ArgumentNullException (Locale.GetText ("bits is a null reference"));
			}

			if (bits.Length != 4) 
			{
				throw new ArgumentException (Locale.GetText ("bits does not contain four values"));
			}

			unchecked {
				lo = (uint) bits[0];
				mid = (uint) bits[1];
				hi = (uint) bits[2];
				flags = (uint) bits[3];
				byte scale = (byte)(flags >> SCALE_SHIFT);
				if (scale > MAX_SCALE || (flags & RESERVED_SS32_BITS) != 0) 
				{
					throw new ArgumentException (Locale.GetText ("Invalid bits[3]"));
				}
			}
		}

		public static decimal FromOACurrency (long cy)
		{
			return (decimal)cy / (decimal)10000;
		}

		public static int[] GetBits (Decimal d) 
		{
			unchecked 
			{
				return new int[] { (int)d.lo, (int)d.mid, (int)d.hi, (int)d.flags };
			}
		}

		public static Decimal Negate (Decimal d) 
		{
			d.flags ^= SIGN_FLAG;
			return d;
		}

		public static Decimal Add (Decimal d1, Decimal d2) 
		{
			if (decimalIncr (ref d1, ref d2) == 0)
				return d1;
			else
				throw new OverflowException (Locale.GetText ("Overflow on adding decimal number"));
		}

		public static Decimal Subtract (Decimal d1, Decimal d2) 
		{
			d2.flags ^= SIGN_FLAG;
			int result = decimalIncr (ref d1, ref d2);
			if (result == 0)
				return d1;
			else
				throw new OverflowException (Locale.GetText ("Overflow on subtracting decimal numbers ("+result+")"));
		}

		public override int GetHashCode () 
		{
			return (int) (flags ^ hi ^ lo ^ mid);
		}

		public static Decimal operator + (Decimal d1, Decimal d2)
		{
			return Add (d1, d2);
		}

		public static Decimal operator -- (Decimal d) 
		{
			return Add(d, MinusOne);
		}

		public static Decimal operator ++ (Decimal d) 
		{
			return Add (d, One);
		}

		public static Decimal operator - (Decimal d1, Decimal d2) 
		{
			return Subtract (d1, d2);
		}

		public static Decimal operator - (Decimal d) 
		{
			return Negate (d);
		}

		public static Decimal operator + (Decimal d) 
		{
			return d;
		}

		public static Decimal operator * (Decimal d1, Decimal d2)
		{
			return Multiply (d1, d2);
		}
		
		public static Decimal operator / (Decimal d1, Decimal d2) 
		{
			return Divide (d1, d2);
		}
		
		public static Decimal operator % (Decimal d1, Decimal d2) 
		{
			return Remainder (d1, d2);
		}

		private static ulong u64 (Decimal value) 
		{
			ulong result;

			decimalFloorAndTrunc (ref value, 0);
			if (decimal2UInt64 (ref value, out result) != 0) {
				throw new System.OverflowException ();
			}
			return result;
		}

		private static long s64 (Decimal value) 
		{
			long result;

			decimalFloorAndTrunc (ref value, 0);
			if (decimal2Int64 (ref value, out result) != 0) {
				throw new System.OverflowException ();
			}
			return result;
		}

		public static explicit operator byte (Decimal value)
		{
			ulong result = u64 (value);
			return checked ((byte) result);
		}

		[CLSCompliant (false)]
		public static explicit operator sbyte (Decimal value)
		{
			long result = s64 (value);
			return checked ((sbyte) result);
		}

		public static explicit operator char (Decimal value) 
		{
			ulong result = u64 (value);
			return checked ((char) result);
		}

		public static explicit operator short (Decimal value) 
		{
			long result = s64 (value);
			return checked ((short) result);
		}

		[CLSCompliant (false)]
		public static explicit operator ushort (Decimal value) 
		{
			ulong result = u64 (value);
			return checked ((ushort) result);
		}

		public static explicit operator int (Decimal value) 
		{
			long result = s64 (value);
			return checked ((int) result);
		}

		[CLSCompliant(false)]
		public static explicit operator uint (Decimal value) 
		{
			ulong result = u64 (value);
			return checked ((uint) result);
		}

		public static explicit operator long (Decimal value) 
		{
			return s64 (value);
		}

		[CLSCompliant(false)]
		public static explicit operator ulong (Decimal value) 
		{
			return u64 (value);
		}

		public static implicit operator Decimal (byte value) 
		{
			return new Decimal (value);
		}

		[CLSCompliant(false)]
		public static implicit operator Decimal (sbyte value) 
		{
			return new Decimal (value);
		}

		public static implicit operator Decimal (short value) 
		{
			return new Decimal (value);
		}

		[CLSCompliant(false)]
		public static implicit operator Decimal (ushort value) 
		{
			return new Decimal (value);
		}

		public static implicit operator Decimal (char value) 
		{
			return new Decimal (value);
		}

		public static implicit operator Decimal (int value) 
		{
			return new Decimal (value);
		}

		[CLSCompliant(false)]
		public static implicit operator Decimal (uint value) 
		{
			return new Decimal (value);
		}

		public static implicit operator Decimal (long value) 
		{
			return new Decimal (value);
		}

		[CLSCompliant(false)]
		public static implicit operator Decimal (ulong value) 
		{
			return new Decimal (value);
		}

		public static explicit operator Decimal (float value) 
		{
			return new Decimal (value);
		}

		public static explicit operator Decimal (double value)
		{
			return new Decimal (value);
		}

		public static explicit operator float (Decimal value)
		{
			return (float) (double) value;
		}

		public static explicit operator double (Decimal value)
		{
			return decimal2double (ref value);
		}


		public static bool operator != (Decimal d1, Decimal d2) 
		{
			return !Equals (d1, d2);
		}

		public static bool operator == (Decimal d1, Decimal d2) 
		{
			return Equals (d1, d2);
		}

		public static bool operator > (Decimal d1, Decimal d2) 
		{
			return Compare (d1, d2) > 0;
		}

		public static bool operator >= (Decimal d1, Decimal d2) 
		{
			return Compare (d1, d2) >= 0;
		}

		public static bool operator < (Decimal d1, Decimal d2) 
		{
			return Compare (d1, d2) < 0;
		}

		public static bool operator <= (Decimal d1, Decimal d2) 
		{
			return Compare (d1, d2) <= 0;
		}

		public static bool Equals (Decimal d1, Decimal d2) 
		{
			return Compare (d1, d2) == 0;
		}

		public override bool Equals (object value) 
		{
			if (!(value is Decimal))
				return false;

			return Equals ((Decimal) value, this);
		}

		// avoid unmanaged call
		private bool IsZero () 
		{
			return ((hi == 0) && (lo == 0) && (mid == 0));
		}

		// avoid unmanaged call
		private bool IsNegative () 
		{
			return ((flags & 0x80000000) == 0x80000000);
		}

		public static Decimal Floor (Decimal d) 
		{
			decimalFloorAndTrunc (ref d, 1);
			return d;
		}

		public static Decimal Truncate (Decimal d) 
		{
			decimalFloorAndTrunc (ref d, 0);
			return d;
		}

		public static Decimal Round (Decimal d, int decimals) 
		{
			return Round (d, decimals, MidpointRounding.ToEven);
		}

		public static Decimal Round (Decimal d, int decimals, MidpointRounding mode) 
		{
			if ((mode != MidpointRounding.ToEven) && (mode != MidpointRounding.AwayFromZero))
				throw new ArgumentException ("The value '" + mode + "' is not valid for this usage of the type MidpointRounding.", "mode");

			if (decimals < 0 || decimals > 28) {
				throw new ArgumentOutOfRangeException ("decimals", "[0,28]");
			}

			bool negative = d.IsNegative ();
			if (negative)
				d.flags ^= SIGN_FLAG;

			// Moved from Math.cs because it's easier to fix the "sign"
			// issue here :( as the logic is OK only for positive numbers
			decimal p = (decimal) Math.Pow (10, decimals);
			decimal int_part = Decimal.Floor (d);
			decimal dec_part = d - int_part;
			dec_part *= 10000000000000000000000000000M;
			dec_part = Decimal.Floor(dec_part);
			dec_part /= (10000000000000000000000000000M / p);
			dec_part = Math.Round (dec_part, mode);

			// ignore trailing zeros
			while (decimals > 0 && (dec_part % 10) == 0) {
				decimals--;
				dec_part /= 10;
				p /= 10;
			}

			dec_part /= p;
			decimal result = int_part + dec_part;

			// that fixes the precision/scale (which we must keep for output)
			// (moved and adapted from System.Data.SqlTypes.SqlMoney)
			long scaleDiff = decimals - ((result.flags & 0x7FFF0000) >> 16);
			// integrify
			if (scaleDiff > 0) {
				// note: here we always work with positive numbers
				while (scaleDiff > 0) {
					if (result > MaxValueDiv10)
						break;
					result *= 10;
					scaleDiff--;
				}
			}
			else if (scaleDiff < 0) {
				while (scaleDiff < 0) {
					result /= 10;
					scaleDiff++;
				}
			}
			result.flags = (uint)((decimals - scaleDiff) << SCALE_SHIFT);

			if (negative)
				result.flags ^= SIGN_FLAG;
			return result;
		}

		public static Decimal Round (Decimal d)
		{
			return Math.Round (d);
		}

		public static Decimal Round (Decimal d, MidpointRounding mode)
		{
			return Math.Round (d, mode);
		}

		public static Decimal Multiply (Decimal d1, Decimal d2) 
		{
			if (d1.IsZero () || d2.IsZero ())
				return Decimal.Zero;

			if (decimalMult (ref d1, ref d2) != 0)
				throw new OverflowException ();
			return d1;
		}

		public static Decimal Divide (Decimal d1, Decimal d2) 
		{
			if (d2.IsZero ())
				throw new DivideByZeroException ();
			if (d1.IsZero ())
				return Decimal.Zero;

			d1.flags ^= SIGN_FLAG;
			d1.flags ^= SIGN_FLAG;

			Decimal result;
			if (decimalDiv (out result, ref d1, ref d2) != 0)
				throw new OverflowException ();

			return result;
		}

		public static Decimal Remainder (Decimal d1, Decimal d2) 
		{
			if (d2.IsZero ())
				throw new DivideByZeroException ();
			if (d1.IsZero ())
				return Decimal.Zero;

			bool negative = d1.IsNegative ();
			if (negative)
				d1.flags ^= SIGN_FLAG;
			if (d2.IsNegative ())
				d2.flags ^= SIGN_FLAG;

			Decimal result;
			if (d1 == d2) {
				return Decimal.Zero;
			}
			else if (d2 > d1) {
				result = d1;
			}
			else {
				if (decimalDiv (out result, ref d1, ref d2) != 0)
					throw new OverflowException ();
				result = Decimal.Truncate (result);

				// FIXME: not really performant here
				result = d1 - result * d2;
			}

			if (negative)
				result.flags ^= SIGN_FLAG;
			return result;
		}

		[ReliabilityContractAttribute (Consistency.WillNotCorruptState, Cer.Success)]
		public static int Compare (Decimal d1, Decimal d2) 
		{
			return decimalCompare (ref d1, ref d2);
		}

		public int CompareTo (object value)
		{
			if (value == null)
				return 1;

			if (!(value is Decimal))
				throw new ArgumentException (Locale.GetText ("Value is not a System.Decimal"));

			return Compare (this, (Decimal)value);
		}

		public int CompareTo (Decimal value)
		{
			return Compare (this, value);
		}

		public bool Equals (Decimal value) 
		{
			return Equals (value, this);
		}

		public static Decimal Ceiling (Decimal d)
		{
			return Math.Ceiling (d);
		}

		public static Decimal Parse (string s) 
		{
			return Parse (s, NumberStyles.Number, null);
		}

		public static Decimal Parse (string s, NumberStyles style) 
		{
			return Parse (s, style, null);
		}

		public static Decimal Parse (string s, IFormatProvider provider) 
		{
			return Parse (s, NumberStyles.Number, provider);
		}

		static void ThrowAtPos (int pos)
		{
			throw new FormatException (String.Format (Locale.GetText ("Invalid character at position {0}"), pos));
		}

		static void ThrowInvalidExp ()
		{
			throw new FormatException (Locale.GetText ("Invalid exponent"));
		}

		private static string stripStyles (string s, NumberStyles style, NumberFormatInfo nfi, 
		  out int decPos, out bool isNegative, out bool expFlag, out int exp, bool throwex)
		{
			isNegative = false;
			expFlag = false;
			exp = 0;
			decPos = -1;

			bool hasSign = false;
			bool hasOpeningParentheses = false;
			bool hasDecimalPoint = false;
			bool allowedLeadingWhiteSpace = ((style & NumberStyles.AllowLeadingWhite) != 0);
			bool allowedTrailingWhiteSpace = ((style & NumberStyles.AllowTrailingWhite) != 0);
			bool allowedLeadingSign = ((style & NumberStyles.AllowLeadingSign) != 0);
			bool allowedTrailingSign = ((style & NumberStyles.AllowTrailingSign) != 0);
			bool allowedParentheses = ((style & NumberStyles.AllowParentheses) != 0);
			bool allowedThousands = ((style & NumberStyles.AllowThousands) != 0);
			bool allowedDecimalPoint = ((style & NumberStyles.AllowDecimalPoint) != 0);
			bool allowedExponent = ((style & NumberStyles.AllowExponent) != 0);

			/* get rid of currency symbol */
			bool hasCurrency = false;
			if ((style & NumberStyles.AllowCurrencySymbol) != 0)
			{
				int index = s.IndexOfOrdinalUnchecked (nfi.CurrencySymbol);
				if (index >= 0) 
				{
					s = s.Remove (index, nfi.CurrencySymbol.Length);
					hasCurrency = true;
				}
			}

			string decimalSep = (hasCurrency) ? nfi.CurrencyDecimalSeparator : nfi.NumberDecimalSeparator;
			string groupSep = (hasCurrency) ? nfi.CurrencyGroupSeparator : nfi.NumberGroupSeparator;
			string negativeSign = nfi.NegativeSign;
			string positiveSign = nfi.PositiveSign;

			// If we don't have a group separator defined, it has the same effect as if it wasn't allowed.
			if (string.IsNullOrEmpty(groupSep)) allowedThousands = false;

			int pos = 0;
			int len = s.Length;

			StringBuilder sb = new StringBuilder (len);

			// leading
			while (pos < len) 
			{
				char ch = s[pos];
				if (Char.IsDigit (ch))
				{
					break; // end of leading
				}
				else if (allowedLeadingWhiteSpace && Char.IsWhiteSpace (ch))
				{
					pos++;
				}
				else if (allowedParentheses && ch == '(' && !hasSign && !hasOpeningParentheses) 
				{
					hasOpeningParentheses = true;
					hasSign = true;
					isNegative = true;
					pos++;
				}
				else if (allowedLeadingSign && !string.IsNullOrEmpty (negativeSign) && ch == negativeSign[0] && !hasSign)
				{
					int slen = negativeSign.Length;
					if (slen == 1 || s.IndexOfOrdinalUnchecked (negativeSign, pos, slen) == pos)
					{
						hasSign = true;
						isNegative = true;
						pos += slen;
					}
				}
				else if (allowedLeadingSign && !string.IsNullOrEmpty (positiveSign) && ch == positiveSign[0] && !hasSign)
				{
					int slen = positiveSign.Length;
					if (slen == 1 || s.IndexOfOrdinalUnchecked (positiveSign, pos, slen) == pos)
					{
						hasSign = true;
						pos += slen;
					}
				}
				else if (allowedDecimalPoint && ch == decimalSep[0])
				{
					int slen = decimalSep.Length;
					if (slen != 1 && s.IndexOfOrdinalUnchecked (decimalSep, pos, slen) != pos) 
					{
						if (throwex)
							ThrowAtPos (pos);
						else
							return null;
					}
					break;
				}
				else
				{
					if (throwex)
						ThrowAtPos (pos);
					else
						return null;
				}
			}

			if (pos == len) {
				if (throwex)
					throw new FormatException (Locale.GetText ("No digits found"));
				else
					return null;
			}

			// digits 
			while (pos < len)
			{
				char ch = s[pos];
				if (Char.IsDigit (ch)) 
				{
					sb.Append(ch);
					pos++;
				}
				else if (allowedThousands && ch == groupSep[0] && ch != decimalSep [0]) 
				{
					int slen = groupSep.Length;
					if (slen != 1 && s.IndexOfOrdinalUnchecked(groupSep, pos, slen) != pos) 
					{
						if (throwex)
							ThrowAtPos (pos);
						else
							return null;
					}
					pos += slen;
				}
				else if (allowedDecimalPoint && ch == decimalSep[0] && !hasDecimalPoint)
				{
					int slen = decimalSep.Length;
					if (slen == 1 || s.IndexOfOrdinalUnchecked(decimalSep, pos, slen) == pos) 
					{
						decPos = sb.Length;
						hasDecimalPoint = true;
						pos += slen;
					}
				}
				else
				{
					break;
				}
			}

			// exponent
			if (pos < len)
			{
				char ch = s[pos];
				if (allowedExponent && Char.ToUpperInvariant (ch) == 'E')
				{
					expFlag = true;
					pos++;
					if (pos >= len){
						if (throwex)
							ThrowInvalidExp ();
						else
							return null;
					}
					ch = s[pos];
					bool isNegativeExp = false;
					if (!string.IsNullOrEmpty (positiveSign) && ch == positiveSign[0])
					{
						int slen = positiveSign.Length;
						if (slen == 1 || s.IndexOfOrdinalUnchecked (positiveSign, pos, slen) == pos)
						{
							pos += slen;
							if (pos >= len) {
								if (throwex)
									ThrowInvalidExp ();
								else
									return null;
							}
						}
					}
					else if (!string.IsNullOrEmpty (negativeSign) && ch == negativeSign[0])
					{
						int slen = negativeSign.Length;
						if (slen == 1 || s.IndexOfOrdinalUnchecked (negativeSign, pos, slen) == pos)
						{
							pos += slen;
							if (pos >= len) {
								if (throwex)
									ThrowInvalidExp ();
								else
									return null;
							}
							isNegativeExp = true;
						}
					}
					ch = s[pos];
					if (!Char.IsDigit(ch)) {
						if (throwex)
							ThrowInvalidExp ();
						else
							return null;
					}

					exp = ch - '0';
					pos++;
					while (pos < len && Char.IsDigit (s[pos])) 
					{
						exp *= 10;
						exp += s[pos] - '0';
						pos++;
					}
					if (isNegativeExp) exp *= -1;
				}
			}

			// trailing
			while (pos < len)
			{
				char ch = s[pos];
				if (allowedTrailingWhiteSpace && Char.IsWhiteSpace (ch)) 
				{
					pos++;
				}
				else if (allowedParentheses && ch == ')' && hasOpeningParentheses) 
				{
					hasOpeningParentheses = false;
					pos++;
				}
				else if (allowedTrailingSign && !string.IsNullOrWhiteSpace (negativeSign) && ch == negativeSign[0] && !hasSign)
				{
					int slen = negativeSign.Length;
					if (slen == 1 || s.IndexOfOrdinalUnchecked(negativeSign, pos, slen) == pos)
					{
						hasSign = true;
						isNegative = true;
						pos += slen;
					}
				}
				else if (allowedTrailingSign && !string.IsNullOrWhiteSpace (positiveSign) && ch == positiveSign[0] && !hasSign)
				{
					int slen = positiveSign.Length;
					if (slen == 1 || s.IndexOfOrdinalUnchecked (positiveSign, pos, slen) == pos)
					{
						hasSign = true;
						pos += slen;
					}
				}
				else
				{
					// trailing zero characters are allowed
					if (ch == 0){
						while (++pos < len && s [pos] == 0)
							;
						if (pos == len)
							break;
					}
					
					if (throwex)
						ThrowAtPos (pos);
					else
						return null;
				}
			}

			if (hasOpeningParentheses) {
				if (throwex)
					throw new FormatException (Locale.GetText ("Closing Parentheses not found"));
				else
					return null;
			}

			if (!hasDecimalPoint)
				decPos = sb.Length;

			return sb.ToString ();
		}

		public static Decimal Parse (string s, NumberStyles style, IFormatProvider provider) 
		{
			if (s == null)
				throw new ArgumentNullException ("s");

			if ((style & NumberStyles.AllowHexSpecifier) != 0)
				throw new ArgumentException ("Decimal.TryParse does not accept AllowHexSpecifier", "style");

			Decimal result;
			PerformParse (s, style, provider, out result, true);
			return result;
		}
	
		public static bool TryParse (string s, out Decimal result)
		{
			if (s == null){
				result = 0;
				return false;
			}
			return PerformParse (s, NumberStyles.Number, null, out result, false);
		}

		public static bool TryParse (string s, NumberStyles style, IFormatProvider provider, out decimal result)
		{
			if (s == null || (style & NumberStyles.AllowHexSpecifier) != 0){
				result = 0;
				return false;
			}

			return PerformParse (s, style, provider, out result, false);
		}

		static bool PerformParse (string s, NumberStyles style, IFormatProvider provider, out Decimal res, bool throwex) 
		{
			NumberFormatInfo nfi = NumberFormatInfo.GetInstance (provider);

			int iDecPos, exp;
			bool isNegative, expFlag;
			s = stripStyles(s, style, nfi, out iDecPos, out isNegative, out expFlag, out exp, throwex);
			if (s == null){
				res = 0;
				return false;
			}

			if (iDecPos < 0){
				if (throwex)
					throw new Exception (Locale.GetText ("Error in System.Decimal.Parse"));
				res = 0;
				return false;
			}

			// first we remove leading 0
			int len = s.Length;
			int i = 0;
			while ((i < iDecPos) && (s [i] == '0'))
				i++;
			if ((i > 1) && (len > 1)) {
				s = s.Substring (i, len - i);
				iDecPos -= i;
			}

			// first 0. may not be here but is part of the maximum length
			int max = ((iDecPos == 0) ? 27 : 28);
			len = s.Length;
			if (len >= max + 1) {
				// number lower than MaxValue (base-less) can have better precision
				if (String.CompareOrdinal (s, 0, "79228162514264337593543950335", 0, max + 1) <= 0) {
					max++;
				}
			}

			// then we trunc the string
			if ((len > max) && (iDecPos < len)) {
				int round = (s [max] - '0');

				bool addone = false;
				if (round > 5) {
					addone = true;
				} else if (round == 5) {
					if (isNegative) {
						addone = true;
					} else {
						// banker's rounding applies
						if (len > max + 1) {
							addone = s [max + 1] > '0';
						} else {
							int previous = s [max - 1] - '0';
							addone = ((previous & 0x01) == 0x01);
						}
					}
				}

				s = s.Substring (0, max);
				if (addone) {
					char[] array = s.ToCharArray ();
					int p = max - 1;
					while (p >= 0) {
						int b = (array [p] - '0');
						if (array [p] != '9') {
							array [p] = (char)(b + '1');
							break;
						}
						else {
							array [p--] = '0';
						}
					}
					if ((p == -1) && (array [0] == '0')) {
						iDecPos++;
						s = "1".PadRight (iDecPos, '0');
					}
					else
						s = new String (array);
				}
			}

			Decimal result;
			// always work in positive (rounding issues)
			if (string2decimal (out result, s, (uint)iDecPos, 0) != 0){
				if (throwex)
					throw new OverflowException ();
				res = 0;
				return false;
			}

			if (expFlag) {
				if (decimalSetExponent (ref result, exp) != 0){
					if (throwex)
						throw new OverflowException ();
					res = 0;
					return false;
				}
			}

			if (isNegative)
				result.flags ^= SIGN_FLAG;

			res = result;
			return true;
		}

		public TypeCode GetTypeCode ()
		{
			return TypeCode.Decimal;
		}

		public static byte ToByte (decimal value)
		{
			if (value > Byte.MaxValue || value < Byte.MinValue)
				throw new OverflowException (Locale.GetText (
					"Value is greater than Byte.MaxValue or less than Byte.MinValue"));

			// return truncated value
			return (byte)(Decimal.Truncate (value));
		}

		public static double ToDouble (decimal d)
		{
			return Convert.ToDouble (d);
		}

		public static short ToInt16 (decimal value)
		{
			if (value > Int16.MaxValue || value < Int16.MinValue)
				throw new OverflowException (Locale.GetText (
					"Value is greater than Int16.MaxValue or less than Int16.MinValue"));

			// return truncated value
			return (Int16)(Decimal.Truncate (value));
		}

		public static int ToInt32 (decimal d)
		{
			if (d > Int32.MaxValue || d < Int32.MinValue)
				throw new OverflowException (Locale.GetText (
					"Value is greater than Int32.MaxValue or less than Int32.MinValue"));

			// return truncated value
			return (Int32)(Decimal.Truncate (d));
		}
	
		public static long ToInt64 (decimal d)
		{
			if (d > Int64.MaxValue || d < Int64.MinValue)
				throw new OverflowException (Locale.GetText (
					"Value is greater than Int64.MaxValue or less than Int64.MinValue"));

			// return truncated value
			return (Int64)(Decimal.Truncate (d));
		}

		public static long ToOACurrency (decimal value)
		{
			return (long) (value * 10000);
		}

		[CLSCompliant(false)]
		public static sbyte ToSByte (decimal value)
		{
			if (value > SByte.MaxValue || value < SByte.MinValue)
				throw new OverflowException (Locale.GetText (
					"Value is greater than SByte.MaxValue or less than SByte.MinValue"));

			// return truncated value
			return (SByte)(Decimal.Truncate (value));
		}
	
		public static float ToSingle (decimal d)
		{
			return Convert.ToSingle (d);
		}

		[CLSCompliant(false)]
		public static ushort ToUInt16 (decimal value)
		{
			if (value > UInt16.MaxValue || value < UInt16.MinValue)
				throw new OverflowException (Locale.GetText (
					"Value is greater than UInt16.MaxValue or less than UInt16.MinValue"));

			// return truncated value
			return (UInt16)(Decimal.Truncate (value));
		}

		[CLSCompliant(false)]
		public static uint ToUInt32 (decimal d)
		{
			if (d > UInt32.MaxValue || d < UInt32.MinValue)
				throw new OverflowException (Locale.GetText (
					"Value is greater than UInt32.MaxValue or less than UInt32.MinValue"));

			// return truncated value
			return (UInt32)(Decimal.Truncate (d));
		}

		[CLSCompliant(false)]
		public static ulong ToUInt64 (decimal d)
		{
			if (d > UInt64.MaxValue || d < UInt64.MinValue)
				throw new OverflowException (Locale.GetText (
					"Value is greater than UInt64.MaxValue or less than UInt64.MinValue"));

			// return truncated value
			return (UInt64)(Decimal.Truncate (d));
		}

		object IConvertible.ToType (Type targetType, IFormatProvider provider)
		{
			if (targetType == null)
				throw new ArgumentNullException ("targetType");
			return Convert.ToType (this, targetType, provider, false);
		}

		bool IConvertible.ToBoolean (IFormatProvider provider)
		{
			return Convert.ToBoolean (this);
		}

		byte IConvertible.ToByte (IFormatProvider provider)
		{
			return Convert.ToByte (this);
		}

		char IConvertible.ToChar (IFormatProvider provider)
		{
			throw new InvalidCastException ();
		}

		DateTime IConvertible.ToDateTime (IFormatProvider provider)
		{
			throw new InvalidCastException ();
		}

		decimal IConvertible.ToDecimal (IFormatProvider provider)
		{
			return this;
		}

		double IConvertible.ToDouble (IFormatProvider provider)
		{
			return Convert.ToDouble (this);
		}

		short IConvertible.ToInt16 (IFormatProvider provider)
		{
			return Convert.ToInt16 (this);
		}

		int IConvertible.ToInt32 (IFormatProvider provider)
		{
			return Convert.ToInt32 (this);
		}

		long IConvertible.ToInt64 (IFormatProvider provider)
		{
			return Convert.ToInt64 (this);
		}

		sbyte IConvertible.ToSByte (IFormatProvider provider)
		{
			return Convert.ToSByte (this);
		}

		float IConvertible.ToSingle (IFormatProvider provider)
		{
			return Convert.ToSingle (this);
		}

		ushort IConvertible.ToUInt16 (IFormatProvider provider)
		{
			return Convert.ToUInt16 (this);
		}

		uint IConvertible.ToUInt32 (IFormatProvider provider)
		{
			return Convert.ToUInt32 (this);
		}

		ulong IConvertible.ToUInt64 (IFormatProvider provider)
		{
			return Convert.ToUInt64 (this);
		}

		public string ToString (string format, IFormatProvider provider) 
		{
			return NumberFormatter.NumberToString (format, this, provider);
		}

		public override string ToString () 
		{
			return ToString ("G", null);
		}

		public string ToString (string format) 
		{
			return ToString (format, null);
		}

		public string ToString (IFormatProvider provider) 
		{
			return ToString ("G", provider);
		}
		
		void IDeserializationCallback.OnDeserialization(object sender)
		{
		}

#if !MSTEST
		[MethodImplAttribute(MethodImplOptions.InternalCall)]
		private static extern int decimal2UInt64 (ref Decimal val, out ulong result);

		[MethodImplAttribute(MethodImplOptions.InternalCall)]
		private static extern int decimal2Int64 (ref Decimal val, out long result);

		[MethodImplAttribute(MethodImplOptions.InternalCall)]
		private static extern int double2decimal (out Decimal erg, double val, int digits);

		[MethodImplAttribute(MethodImplOptions.InternalCall)]
		private static extern int decimalIncr (ref Decimal d1, ref Decimal d2);

		[MethodImplAttribute(MethodImplOptions.InternalCall)]
		internal static extern int string2decimal (out Decimal val, String sDigits, uint decPos, int sign);

		[MethodImplAttribute(MethodImplOptions.InternalCall)]
		internal static extern int decimalSetExponent (ref Decimal val, int exp);

		[MethodImplAttribute(MethodImplOptions.InternalCall)]
		private static extern double decimal2double (ref Decimal val);

		[MethodImplAttribute(MethodImplOptions.InternalCall)]
		private static extern void decimalFloorAndTrunc (ref Decimal val, int floorFlag);

//		[MethodImplAttribute(MethodImplOptions.InternalCall)]
//		private static extern void decimalRound (ref Decimal val, int decimals);

		[MethodImplAttribute(MethodImplOptions.InternalCall)]
		private static extern int decimalMult (ref Decimal pd1, ref Decimal pd2);

		[MethodImplAttribute(MethodImplOptions.InternalCall)]
		private static extern int decimalDiv (out Decimal pc, ref Decimal pa, ref Decimal pb);

		[MethodImplAttribute(MethodImplOptions.InternalCall)]
		private static extern int decimalIntDiv (out Decimal pc, ref Decimal pa, ref Decimal pb);

		[MethodImplAttribute(MethodImplOptions.InternalCall)]
		private static extern int decimalCompare (ref Decimal d1, ref Decimal d2);
#else
		//![MethodImplAttribute(MethodImplOptions.InternalCall)]
		[DllImport("libdec", EntryPoint="decimal2UInt64")]
		private static extern int decimal2UInt64 (ref Decimal val, out ulong result);

		//![MethodImplAttribute(MethodImplOptions.InternalCall)]
		[DllImport("libdec", EntryPoint="decimal2Int64")]
		private static extern int decimal2Int64 (ref Decimal val, out long result);

		//![MethodImplAttribute(MethodImplOptions.InternalCall)]
		[DllImport("libdec", EntryPoint="double2decimal")]
		private static extern int double2decimal (out Decimal erg, double val, int digits);

		//![MethodImplAttribute(MethodImplOptions.InternalCall)]
		[DllImport("libdec", EntryPoint="decimalIncr")]
		private static extern int decimalIncr (ref Decimal d1, ref Decimal d2);

		//![MethodImplAttribute(MethodImplOptions.InternalCall)]
		[DllImport("libdec", EntryPoint="string2decimal")]
		internal static extern int string2decimal (out Decimal val,
		    [MarshalAs(UnmanagedType.LPWStr)]String sDigits,
		    uint decPos, int sign);

		//![MethodImplAttribute(MethodImplOptions.InternalCall)]
		[DllImport("libdec", EntryPoint="decimalSetExponent")]
		internal static extern int decimalSetExponent (ref Decimal val, int exp);

		//![MethodImplAttribute(MethodImplOptions.InternalCall)]
		[DllImport("libdec", EntryPoint="decimal2double")]
		private static extern double decimal2double (ref Decimal val);

		//![MethodImplAttribute(MethodImplOptions.InternalCall)]
		[DllImport("libdec", EntryPoint="decimalFloorAndTrunc")]
		private static extern void decimalFloorAndTrunc (ref Decimal val, int floorFlag);

		//![MethodImplAttribute(MethodImplOptions.InternalCall)]
		[DllImport("libdec", EntryPoint="decimalRound")]
		private static extern void decimalRound (ref Decimal val, int decimals);

		//![MethodImplAttribute(MethodImplOptions.InternalCall)]
		[DllImport("libdec", EntryPoint="decimalMult")]
		private static extern int decimalMult (ref Decimal pd1, ref Decimal pd2);

		//![MethodImplAttribute(MethodImplOptions.InternalCall)]
		[DllImport("libdec", EntryPoint="decimalDiv")]
		private static extern int decimalDiv (out Decimal pc, ref Decimal pa, ref Decimal pb);

		//![MethodImplAttribute(MethodImplOptions.InternalCall)]
		[DllImport("libdec", EntryPoint="decimalIntDiv")]
		private static extern int decimalIntDiv (out Decimal pc, ref Decimal pa, ref Decimal pb);

		//![MethodImplAttribute(MethodImplOptions.InternalCall)]
		[DllImport("libdec", EntryPoint="decimalCompare")]
		private static extern int decimalCompare (ref Decimal d1, ref Decimal d2);

#endif
	}
}