// ==++==
// 
//   Copyright (c) Microsoft Corporation.  All rights reserved.
// 
// ==--==
// The BigNumber class implements methods for formatting and parsing
// big numeric values. To format and parse numeric values, applications should
// use the Format and Parse methods provided by the numeric
// classes (BigInteger). Those
// Format and Parse methods share a common implementation
// provided by this class, and are thus documented in detail here.
//
// Formatting
//
// The Format methods provided by the numeric classes are all of the
// form
//
//  public static String Format(XXX value, String format);
//  public static String Format(XXX value, String format, NumberFormatInfo info);
//
// where XXX is the name of the particular numeric class. The methods convert
// the numeric value to a string using the format string given by the
// format parameter. If the format parameter is null or
// an empty string, the number is formatted as if the string "G" (general
// format) was specified. The info parameter specifies the
// NumberFormatInfo instance to use when formatting the number. If the
// info parameter is null or omitted, the numeric formatting information
// is obtained from the current culture. The NumberFormatInfo supplies
// such information as the characters to use for decimal and thousand
// separators, and the spelling and placement of currency symbols in monetary
// values.
//
// Format strings fall into two categories: Standard format strings and
// user-defined format strings. A format string consisting of a single
// alphabetic character (A-Z or a-z), optionally followed by a sequence of
// digits (0-9), is a standard format string. All other format strings are
// used-defined format strings.
//
// A standard format string takes the form Axx, where A is an
// alphabetic character called the format specifier and xx is a
// sequence of digits called the precision specifier. The format
// specifier controls the type of formatting applied to the number and the
// precision specifier controls the number of significant digits or decimal
// places of the formatting operation. The following table describes the
// supported standard formats.
//
// C c - Currency format. The number is
// converted to a string that represents a currency amount. The conversion is
// controlled by the currency format information of the NumberFormatInfo
// used to format the number. The precision specifier indicates the desired
// number of decimal places. If the precision specifier is omitted, the default
// currency precision given by the NumberFormatInfo is used.
//
// D d - Decimal format. This format is
// supported for integral types only. The number is converted to a string of
// decimal digits, prefixed by a minus sign if the number is negative. The
// precision specifier indicates the minimum number of digits desired in the
// resulting string. If required, the number will be left-padded with zeros to
// produce the number of digits given by the precision specifier.
//
// E e Engineering (scientific) format.
// The number is converted to a string of the form
// "-d.ddd...E+ddd" or "-d.ddd...e+ddd", where each
// 'd' indicates a digit (0-9). The string starts with a minus sign if the
// number is negative, and one digit always precedes the decimal point. The
// precision specifier indicates the desired number of digits after the decimal
// point. If the precision specifier is omitted, a default of 6 digits after
// the decimal point is used. The format specifier indicates whether to prefix
// the exponent with an 'E' or an 'e'. The exponent is always consists of a
// plus or minus sign and three digits.
//
// F f Fixed point format. The number is
// converted to a string of the form "-ddd.ddd....", where each
// 'd' indicates a digit (0-9). The string starts with a minus sign if the
// number is negative. The precision specifier indicates the desired number of
// decimal places. If the precision specifier is omitted, the default numeric
// precision given by the NumberFormatInfo is used.
//
// G g - General format. The number is
// converted to the shortest possible decimal representation using fixed point
// or scientific format. The precision specifier determines the number of
// significant digits in the resulting string. If the precision specifier is
// omitted, the number of significant digits is determined by the type of the
// number being converted (10 for int, 19 for long, 7 for
// float, 15 for double, 19 for Currency, and 29 for
// Decimal). Trailing zeros after the decimal point are removed, and the
// resulting string contains a decimal point only if required. The resulting
// string uses fixed point format if the exponent of the number is less than
// the number of significant digits and greater than or equal to -4. Otherwise,
// the resulting string uses scientific format, and the case of the format
// specifier controls whether the exponent is prefixed with an 'E' or an
// 'e'.
//
// N n Number format. The number is
// converted to a string of the form "-d,ddd,ddd.ddd....", where
// each 'd' indicates a digit (0-9). The string starts with a minus sign if the
// number is negative. Thousand separators are inserted between each group of
// three digits to the left of the decimal point. The precision specifier
// indicates the desired number of decimal places. If the precision specifier
// is omitted, the default numeric precision given by the
// NumberFormatInfo is used.
//
// X x - Hexadecimal format. This format is
// supported for integral types only. The number is converted to a string of
// hexadecimal digits. The format specifier indicates whether to use upper or
// lower case characters for the hexadecimal digits above 9 ('X' for 'ABCDEF',
// and 'x' for 'abcdef'). The precision specifier indicates the minimum number
// of digits desired in the resulting string. If required, the number will be
// left-padded with zeros to produce the number of digits given by the
// precision specifier.
//
// Some examples of standard format strings and their results are shown in the
// table below. (The examples all assume a default NumberFormatInfo.)
//
// Value        Format  Result
// 12345.6789   C       $12,345.68
// -12345.6789  C       ($12,345.68)
// 12345        D       12345
// 12345        D8      00012345
// 12345.6789   E       1.234568E+004
// 12345.6789   E10     1.2345678900E+004
// 12345.6789   e4      1.2346e+004
// 12345.6789   F       12345.68
// 12345.6789   F0      12346
// 12345.6789   F6      12345.678900
// 12345.6789   G       12345.6789
// 12345.6789   G7      12345.68
// 123456789    G7      1.234568E8
// 12345.6789   N       12,345.68
// 123456789    N4      123,456,789.0000
// 0x2c45e      x       2c45e
// 0x2c45e      X       2C45E
// 0x2c45e      X8      0002C45E
//
// Format strings that do not start with an alphabetic character, or that start
// with an alphabetic character followed by a non-digit, are called
// user-defined format strings. The following table describes the formatting
// characters that are supported in user defined format strings.
//
// 
// 0 - Digit placeholder. If the value being
// formatted has a digit in the position where the '0' appears in the format
// string, then that digit is copied to the output string. Otherwise, a '0' is
// stored in that position in the output string. The position of the leftmost
// '0' before the decimal point and the rightmost '0' after the decimal point
// determines the range of digits that are always present in the output
// string.
//
// # - Digit placeholder. If the value being
// formatted has a digit in the position where the '#' appears in the format
// string, then that digit is copied to the output string. Otherwise, nothing
// is stored in that position in the output string.
//
// . - Decimal point. The first '.' character
// in the format string determines the location of the decimal separator in the
// formatted value; any additional '.' characters are ignored. The actual
// character used as a the decimal separator in the output string is given by
// the NumberFormatInfo used to format the number.
//
// , - Thousand separator and number scaling.
// The ',' character serves two purposes. First, if the format string contains
// a ',' character between two digit placeholders (0 or #) and to the left of
// the decimal point if one is present, then the output will have thousand
// separators inserted between each group of three digits to the left of the
// decimal separator. The actual character used as a the decimal separator in
// the output string is given by the NumberFormatInfo used to format the
// number. Second, if the format string contains one or more ',' characters
// immediately to the left of the decimal point, or after the last digit
// placeholder if there is no decimal point, then the number will be divided by
// 1000 times the number of ',' characters before it is formatted. For example,
// the format string '0,,' will represent 100 million as just 100. Use of the
// ',' character to indicate scaling does not also cause the formatted number
// to have thousand separators. Thus, to scale a number by 1 million and insert
// thousand separators you would use the format string '#,##0,,'.
//
// % - Percentage placeholder. The presence of
// a '%' character in the format string causes the number to be multiplied by
// 100 before it is formatted. The '%' character itself is inserted in the
// output string where it appears in the format string.
//
// E+ E- e+ e-   - Scientific notation.
// If any of the strings 'E+', 'E-', 'e+', or 'e-' are present in the format
// string and are immediately followed by at least one '0' character, then the
// number is formatted using scientific notation with an 'E' or 'e' inserted
// between the number and the exponent. The number of '0' characters following
// the scientific notation indicator determines the minimum number of digits to
// output for the exponent. The 'E+' and 'e+' formats indicate that a sign
// character (plus or minus) should always precede the exponent. The 'E-' and
// 'e-' formats indicate that a sign character should only precede negative
// exponents.
//
// \ - Literal character. A backslash character
// causes the next character in the format string to be copied to the output
// string as-is. The backslash itself isn't copied, so to place a backslash
// character in the output string, use two backslashes (\\) in the format
// string.
//
// 'ABC' "ABC" - Literal string. Characters
// enclosed in single or double quotation marks are copied to the output string
// as-is and do not affect formatting.
//
// ; - Section separator. The ';' character is
// used to separate sections for positive, negative, and zero numbers in the
// format string.
//
// Other - All other characters are copied to
// the output string in the position they appear.
//
// For fixed point formats (formats not containing an 'E+', 'E-', 'e+', or
// 'e-'), the number is rounded to as many decimal places as there are digit
// placeholders to the right of the decimal point. If the format string does
// not contain a decimal point, the number is rounded to the nearest
// integer. If the number has more digits than there are digit placeholders to
// the left of the decimal point, the extra digits are copied to the output
// string immediately before the first digit placeholder.
//
// For scientific formats, the number is rounded to as many significant digits
// as there are digit placeholders in the format string.
//
// To allow for different formatting of positive, negative, and zero values, a
// user-defined format string may contain up to three sections separated by
// semicolons. The results of having one, two, or three sections in the format
// string are described in the table below.
//
// Sections:
//
// One - The format string applies to all values.
//
// Two - The first section applies to positive values
// and zeros, and the second section applies to negative values. If the number
// to be formatted is negative, but becomes zero after rounding according to
// the format in the second section, then the resulting zero is formatted
// according to the first section.
//
// Three - The first section applies to positive
// values, the second section applies to negative values, and the third section
// applies to zeros. The second section may be left empty (by having no
// characters between the semicolons), in which case the first section applies
// to all non-zero values. If the number to be formatted is non-zero, but
// becomes zero after rounding according to the format in the first or second
// section, then the resulting zero is formatted according to the third
// section.
//
// For both standard and user-defined formatting operations on values of type
// float and double, if the value being formatted is a NaN (Not
// a Number) or a positive or negative infinity, then regardless of the format
// string, the resulting string is given by the NaNSymbol,
// PositiveInfinitySymbol, or NegativeInfinitySymbol property of
// the NumberFormatInfo used to format the number.
//
// Parsing
//
// The Parse methods provided by the numeric classes are all of the form
//
//  public static XXX Parse(String s);
//  public static XXX Parse(String s, int style);
//  public static XXX Parse(String s, int style, NumberFormatInfo info);
//
// where XXX is the name of the particular numeric class. The methods convert a
// string to a numeric value. The optional style parameter specifies the
// permitted style of the numeric string. It must be a combination of bit flags
// from the NumberStyles enumeration. The optional info parameter
// specifies the NumberFormatInfo instance to use when parsing the
// string. If the info parameter is null or omitted, the numeric
// formatting information is obtained from the current culture.
//
// Numeric strings produced by the Format methods using the Currency,
// Decimal, Engineering, Fixed point, General, or Number standard formats
// (the C, D, E, F, G, and N format specifiers) are guaranteed to be parseable
// by the Parse methods if the NumberStyles.Any style is
// specified. Note, however, that the Parse methods do not accept
// NaNs or Infinities.
//
namespace System.Numerics {
    using System;
    using System.Diagnostics.Contracts;
    using System.Globalization;
    using System.Runtime.CompilerServices;
    using System.Security;
    using System.Text;
    using Conditional = System.Diagnostics.ConditionalAttribute;

    internal static class BigNumber {

#if !SILVERLIGHT || FEATURE_NETCORE
        private const NumberStyles InvalidNumberStyles = ~(NumberStyles.AllowLeadingWhite | NumberStyles.AllowTrailingWhite
                                                           | NumberStyles.AllowLeadingSign | NumberStyles.AllowTrailingSign
                                                           | NumberStyles.AllowParentheses | NumberStyles.AllowDecimalPoint
                                                           | NumberStyles.AllowThousands | NumberStyles.AllowExponent
                                                           | NumberStyles.AllowCurrencySymbol | NumberStyles.AllowHexSpecifier);

        internal struct BigNumberBuffer {
            public StringBuilder digits;
            public int precision;
            public int scale;
            public bool sign;  // negative sign exists

            public static BigNumberBuffer Create() {
                BigNumberBuffer number = new BigNumberBuffer();
                number.digits = new StringBuilder();
                return number;
            }
        }

        internal static bool TryValidateParseStyleInteger(NumberStyles style, out ArgumentException e) {
            // Check for undefined flags
            if ((style & InvalidNumberStyles) != 0) {
                e = new ArgumentException(SR.GetString(SR.Argument_InvalidNumberStyles, "style"));
                return false;
            }
            if ((style & NumberStyles.AllowHexSpecifier) != 0) { // Check for hex number
                if ((style & ~NumberStyles.HexNumber) != 0) {
                    e = new ArgumentException(SR.GetString(SR.Argument_InvalidHexStyle));
                    return false;
                }
            }
            e = null;
            return true;
        }

        [SecuritySafeCritical]
        internal unsafe static Boolean TryParseBigInteger(String value, NumberStyles style, NumberFormatInfo info, out BigInteger result) {
            result = BigInteger.Zero;
            ArgumentException e;
            if (!TryValidateParseStyleInteger(style, out e))
                throw e; // TryParse still throws ArgumentException on invalid NumberStyles

            BigNumberBuffer bignumber = BigNumberBuffer.Create();
            Byte * numberBufferBytes = stackalloc Byte[Number.NumberBuffer.NumberBufferBytes];
            Number.NumberBuffer number = new Number.NumberBuffer(numberBufferBytes);
            result = 0;
    
            if (!Number.TryStringToNumber(value, style, ref number, bignumber.digits, info, false)) {
                return false;
            }
            bignumber.precision = number.precision;
            bignumber.scale = number.scale;
            bignumber.sign = number.sign;

            if ((style & NumberStyles.AllowHexSpecifier) != 0) {
                if (!HexNumberToBigInteger(ref bignumber, ref result)) { 
                    return false;
                }
            }
            else {
                if (!NumberToBigInteger(ref bignumber, ref result)) {
                    return false;
                }
            }
            return true;           
        }

        internal unsafe static BigInteger ParseBigInteger(String value, NumberStyles style, NumberFormatInfo info) {
            if (value == null)
                throw new ArgumentNullException("value");

            ArgumentException e;
            if (!TryValidateParseStyleInteger(style, out e))
                throw e;

            BigInteger result = BigInteger.Zero;
            if (!TryParseBigInteger(value, style, info, out result)) {
                throw new FormatException(SR.GetString(SR.Overflow_ParseBigInteger));
            }
            return result;
        }

        private unsafe static Boolean HexNumberToBigInteger(ref BigNumberBuffer number, ref BigInteger value) {
            if (number.digits == null || number.digits.Length == 0)
                return false;

            int len = number.digits.Length - 1; // ignore trailing '\0'
            byte[] bits = new byte[(len / 2) + (len % 2)];

            bool shift = false;
            bool isNegative = false;
            int bitIndex = 0;

            // parse the string into a little-endian two's complement byte array
            // string value     : O F E B 7 \0
            // string index (i) : 0 1 2 3 4 5 <--
            // byte[] (bitIndex): 2 1 1 0 0 <--
            //
            for (int i = len-1; i > -1; i--) {
                char c = number.digits[i];

                byte b;
                if (c >= '0' && c <= '9') {
                    b = (byte)(c - '0');
                }
                else if (c >= 'A' && c <= 'F') {
                    b = (byte)((c - 'A') + 10);
                }
                else {
                    Contract.Assert(c >= 'a' && c <= 'f');
                    b = (byte)((c - 'a') + 10);
                }
                if (i == 0 && (b & 0x08) == 0x08)
                    isNegative = true;

                if (shift) {
                    bits[bitIndex] = (byte)(bits[bitIndex] | (b << 4));
                    bitIndex++;                    
                }
                else {
                    bits[bitIndex] = isNegative ? (byte)(b | 0xF0) : (b);
                }
                shift = !shift;
            }

            value = new BigInteger(bits);
            return true;
        }

        private unsafe static Boolean NumberToBigInteger(ref BigNumberBuffer number, ref BigInteger value) {
            Int32 i = number.scale;
            Int32 cur = 0;

            value = 0;
            while (--i >= 0) {
                value *= 10;
                if (number.digits[cur] != '\0') {
                    value += (Int32)(number.digits[cur++] - '0');
                }
            }
            while (number.digits[cur] != '\0') {
                if (number.digits[cur++] != '0') return false; // disallow non-zero trailing decimal places
            }
            if (number.sign) {
                value = -value;
            }
            return true;
        }
#endif //!SILVERLIGHT ||FEATURE_NETCORE

        // this function is consistent with VM\COMNumber.cpp!COMNumber::ParseFormatSpecifier
        internal static char ParseFormatSpecifier(String format, out Int32 digits) {
            digits = -1;
            if (String.IsNullOrEmpty(format)) {
                return 'R';
            }

            int i = 0;
            char ch = format[i];
            if (ch >= 'A' && ch <= 'Z' || ch >= 'a' && ch <= 'z') {
                i++;
                int n = -1;

                if (i < format.Length && format[i] >= '0' && format[i] <= '9') {
                    n = format[i++] - '0';
                    while (i < format.Length &&  format[i] >= '0' && format[i] <= '9') {
                        n = n * 10 + (format[i++] - '0');
                        if (n >= 10)
                            break;
                    }
                }
                if (i >= format.Length || format[i] == '\0') {
                    digits = n;
                    return ch;
                }
            }
            return (char)0; // custom format
        }

        private static String FormatBigIntegerToHexString(BigInteger value, char format, int digits, NumberFormatInfo info) {
            StringBuilder sb = new StringBuilder();
            byte[] bits = value.ToByteArray();
            String fmt = null;
            int cur = bits.Length-1;
           
            if (cur > -1) {
                // [FF..F8] drop the high F as the two's complement negative number remains clear
                // [F7..08] retain the high bits as the two's complement number is wrong without it
                // [07..00] drop the high 0 as the two's complement positive number remains clear
                bool clearHighF = false;
                byte head = bits[cur];
                if (head > 0xF7) {
                    head -= 0xF0;
                    clearHighF = true;
                }
                if (head < 0x08 || clearHighF) {
                    // {0xF8-0xFF} print as {8-F}
                    // {0x00-0x07} print as {0-7}
                    fmt = String.Format(CultureInfo.InvariantCulture, "{0}1", format);
                    sb.Append(head.ToString(fmt, info));
                    cur--;
                }
            }
            if (cur > -1) {
                fmt = String.Format(CultureInfo.InvariantCulture, "{0}2", format);
                while (cur > -1) {
                    sb.Append(bits[cur--].ToString(fmt, info));
                }
            }
            if (digits > 0 && digits > sb.Length) {
                // insert leading zeros.  User specified "X5" so we create "0ABCD" instead of "ABCD"
                sb.Insert(0, (value._sign >= 0 ? ("0") : (format == 'x' ? "f" : "F")), digits - sb.Length);
            }          
            return sb.ToString();
        }

        //
        // internal [unsafe] static String FormatBigInteger(BigInteger value, String format, NumberFormatInfo info) {
        //
#if !SILVERLIGHT ||FEATURE_NETCORE
        [SecuritySafeCritical]
#endif // !SILVERLIGHT ||FEATURE_NETCORE
        internal
#if !SILVERLIGHT ||FEATURE_NETCORE
                 unsafe
#endif //!SILVERLIGHT ||FEATURE_NETCORE
                        static String FormatBigInteger(BigInteger value, String format, NumberFormatInfo info) {
            int digits = 0;
            char fmt = ParseFormatSpecifier(format, out digits);
            if (fmt == 'x' || fmt == 'X')
                return FormatBigIntegerToHexString(value, fmt, digits, info);

            bool decimalFmt = (fmt == 'g' || fmt == 'G' || fmt == 'd' || fmt == 'D' || fmt == 'r' || fmt == 'R');           

#if SILVERLIGHT ||FEATURE_NETCORE || MONO
            if (!decimalFmt) {
                // Silverlight supports invariant formats only
                throw new FormatException(SR.GetString(SR.Format_InvalidFormatSpecifier));
            }
#endif //SILVERLIGHT ||FEATURE_NETCORE || MONO

            if (value._bits == null) {
                if (fmt == 'g' || fmt == 'G' || fmt == 'r' || fmt == 'R') {
                    if (digits > 0)
                        format = String.Format(CultureInfo.InvariantCulture, "D{0}", digits.ToString(CultureInfo.InvariantCulture));
                    else
                        format = "D";
                }
                return value._sign.ToString(format, info);
            }


            // First convert to base 10^9.
            const uint kuBase = 1000000000; // 10^9
            const int kcchBase = 9;

            int cuSrc = BigInteger.Length(value._bits);
            int cuMax;
            try {
                cuMax = checked(cuSrc * 10 / 9 + 2);
            }
            catch (OverflowException e) { throw new FormatException(SR.GetString(SR.Format_TooLarge), e); }
            uint[] rguDst = new uint[cuMax];
            int cuDst = 0;

            for (int iuSrc = cuSrc; --iuSrc >= 0; ) {
                uint uCarry = value._bits[iuSrc];
                for (int iuDst = 0; iuDst < cuDst; iuDst++) {
                    Contract.Assert(rguDst[iuDst] < kuBase);
                    ulong uuRes = NumericsHelpers.MakeUlong(rguDst[iuDst], uCarry);
                    rguDst[iuDst] = (uint)(uuRes % kuBase);
                    uCarry = (uint)(uuRes / kuBase);
                }
                if (uCarry != 0) {
                    rguDst[cuDst++] = uCarry % kuBase;
                    uCarry /= kuBase;
                    if (uCarry != 0)
                        rguDst[cuDst++] = uCarry;
                }
            }

            int cchMax;
            try {
                // Each uint contributes at most 9 digits to the decimal representation.
                cchMax = checked(cuDst * kcchBase);
            }
            catch (OverflowException e) { throw new FormatException(SR.GetString(SR.Format_TooLarge), e); }

            if (decimalFmt) {
                if (digits > 0 && digits > cchMax)
                    cchMax = digits;
                if (value._sign < 0) {
                    try {
                        // Leave an extra slot for a minus sign.
                        cchMax = checked(cchMax + info.NegativeSign.Length);
                    }
                    catch (OverflowException e) { throw new FormatException(SR.GetString(SR.Format_TooLarge), e); }
                }
            }

            int rgchBufSize;

            try {
                // We'll pass the rgch buffer to native code, which is going to treat it like a string of digits, so it needs
                // to be null terminated.  Let's ensure that we can allocate a buffer of that size.
                rgchBufSize = checked(cchMax + 1);
            } catch (OverflowException e) { throw new FormatException(SR.GetString(SR.Format_TooLarge), e); }

            char[] rgch = new char[rgchBufSize];

            int ichDst = cchMax;

            for (int iuDst = 0; iuDst < cuDst - 1; iuDst++) {
                uint uDig = rguDst[iuDst];
                Contract.Assert(uDig < kuBase);
                for (int cch = kcchBase; --cch >= 0; ) {
                    rgch[--ichDst] = (char)('0' + uDig % 10);
                    uDig /= 10;
                }
            }
            for (uint uDig = rguDst[cuDst - 1]; uDig != 0; ) {
                rgch[--ichDst] = (char)('0' + uDig % 10);
                uDig /= 10;
            }

#if !SILVERLIGHT ||FEATURE_NETCORE
            if (!decimalFmt) {
                //
                // Go to the VM for GlobLoc aware formatting
                //    
                Byte * numberBufferBytes = stackalloc Byte[Number.NumberBuffer.NumberBufferBytes];
                Number.NumberBuffer number = new Number.NumberBuffer(numberBufferBytes);
                // sign = true for negative and false for 0 and positive values
                number.sign = (value._sign < 0);
                // the cut-off point to switch (G)eneral from (F)ixed-point to (E)xponential form
                number.precision = 29;
                number.digits[0] = '\0';    
                number.scale = cchMax - ichDst;

                int maxDigits = Math.Min(ichDst + 50, cchMax);
                for (int i = ichDst; i < maxDigits; i++) {
                    number.digits[i - ichDst] = rgch[i];
                }
              
                fixed(char* pinnedExtraDigits = rgch) {
                    return Number.FormatNumberBuffer(number.PackForNative(), format, info, pinnedExtraDigits + ichDst);
                }
            }
#endif //!SILVERLIGHT ||FEATURE_NETCORE

            // Format Round-trip decimal
            // This format is supported for integral types only. The number is converted to a string of
            // decimal digits (0-9), prefixed by a minus sign if the number is negative. The precision
            // specifier indicates the minimum number of digits desired in the resulting string. If required,
            // the number is padded with zeros to its left to produce the number of digits given by the
            // precision specifier.
            int numDigitsPrinted = cchMax - ichDst;               
            while (digits > 0 && digits > numDigitsPrinted) {
                // pad leading zeros
                rgch[--ichDst] = '0';
                digits--;                    
            }
            if (value._sign < 0) {
                String negativeSign = info.NegativeSign;
                for (int i = info.NegativeSign.Length - 1; i > -1; i--)
                    rgch[--ichDst] = info.NegativeSign[i];
            }
            return new String(rgch, ichDst, cchMax - ichDst);
        }
    }
}