ParseNumber()

static unsafe bool System.Globalization.FormatProvider.Number.ParseNumber ( ref char * str, char * strEnd, NumberStyles options, ref NumberBuffer number, StringBuilder sb, NumberFormatInfo numfmt, bool parseDecimal )

inlinestaticprivate

Definition at line 126 of file FormatProvider.cs.

        {
            number.scale = 0;
            number.sign = false;
            string text = null;
            bool allowHyphenDuringParsing = AllowHyphenDuringParsing(numfmt);
            bool flag = false;
            string str2;
            string str3;
            if ((options & NumberStyles.AllowCurrencySymbol) != 0)
            {
                text = numfmt.CurrencySymbol;
                str2 = numfmt.CurrencyDecimalSeparator;
                str3 = numfmt.CurrencyGroupSeparator;
                flag = true;
            }
            else
            {
                str2 = numfmt.NumberDecimalSeparator;
                str3 = numfmt.NumberGroupSeparator;
            }
            int num = 0;
            bool flag2 = sb != null;
            int num2 = (flag2 ? int.MaxValue : 32);
            char* ptr = str;
            char c = ((ptr < strEnd) ? (*ptr) : '\0');
            char* digits = number.digits;
            while (true)
            {
                if (!IsWhite(c) || (options & NumberStyles.AllowLeadingWhite) == 0 || (((uint)num & (true ? 1u : 0u)) != 0 && (num & 0x20) == 0 && numfmt.NumberNegativePattern != 2))
                {
                    char* ptr2;
                    if ((options & NumberStyles.AllowLeadingSign) != 0 && (num & 1) == 0 && ((ptr2 = MatchChars(ptr, strEnd, numfmt.PositiveSign)) != null || ((ptr2 = MatchNegativeSignChars(ptr, strEnd, numfmt.NegativeSign, allowHyphenDuringParsing)) != null && (number.sign = true))))
                    {
                        num |= 1;
                        ptr = ptr2 - 1;
                    }
                    else if (c == '(' && (options & NumberStyles.AllowParentheses) != 0 && (num & 1) == 0)
                    {
                        num |= 3;
                        number.sign = true;
                    }
                    else
                    {
                        if (text == null || (ptr2 = MatchChars(ptr, strEnd, text)) == null)
                        {
                            break;
                        }
                        num |= 0x20;
                        text = null;
                        ptr = ptr2 - 1;
                    }
                }
                c = ((++ptr < strEnd) ? (*ptr) : '\0');
            }
            int num3 = 0;
            int num4 = 0;
            while (true)
            {
                char* ptr2;
                if ((c >= '0' && c <= '9') || ((options & NumberStyles.AllowHexSpecifier) != 0 && ((c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F'))))
                {
                    num |= 4;
                    if (c != '0' || ((uint)num & 8u) != 0 || (flag2 && (options & NumberStyles.AllowHexSpecifier) != 0))
                    {
                        if (num3 < num2)
                        {
                            if (flag2)
                            {
                                sb.Append(c);
                            }
                            else
                            {
                                digits[num3++] = c;
                            }
                            if (c != '0' || parseDecimal)
                            {
                                num4 = num3;
                            }
                        }
                        if ((num & 0x10) == 0)
                        {
                            number.scale++;
                        }
                        num |= 8;
                    }
                    else if (((uint)num & 0x10u) != 0)
                    {
                        number.scale--;
                    }
                }
                else if ((options & NumberStyles.AllowDecimalPoint) != 0 && (num & 0x10) == 0 && ((ptr2 = MatchChars(ptr, strEnd, str2)) != null || (flag && (num & 0x20) == 0 && (ptr2 = MatchChars(ptr, strEnd, numfmt.NumberDecimalSeparator)) != null)))
                {
                    num |= 0x10;
                    ptr = ptr2 - 1;
                }
                else
                {
                    if ((options & NumberStyles.AllowThousands) == 0 || (num & 4) == 0 || ((uint)num & 0x10u) != 0 || ((ptr2 = MatchChars(ptr, strEnd, str3)) == null && (!flag || ((uint)num & 0x20u) != 0 || (ptr2 = MatchChars(ptr, strEnd, numfmt.NumberGroupSeparator)) == null)))
                    {
                        break;
                    }
                    ptr = ptr2 - 1;
                }
                c = ((++ptr < strEnd) ? (*ptr) : '\0');
            }
            bool flag3 = false;
            number.precision = num4;
            if (flag2)
            {
                sb.Append('\0');
            }
            else
            {
                digits[num4] = '\0';
            }
            if (((uint)num & 4u) != 0)
            {
                if ((c == 'E' || c == 'e') && (options & NumberStyles.AllowExponent) != 0)
                {
                    char* ptr3 = ptr;
                    c = ((++ptr < strEnd) ? (*ptr) : '\0');
                    char* ptr2;
                    if ((ptr2 = MatchChars(ptr, strEnd, numfmt.PositiveSign)) != null)
                    {
                        c = (((ptr = ptr2) < strEnd) ? (*ptr) : '\0');
                    }
                    else if ((ptr2 = MatchNegativeSignChars(ptr, strEnd, numfmt.NegativeSign, allowHyphenDuringParsing)) != null)
                    {
                        c = (((ptr = ptr2) < strEnd) ? (*ptr) : '\0');
                        flag3 = true;
                    }
                    if (c >= '0' && c <= '9')
                    {
                        int num5 = 0;
                        do
                        {
                            num5 = num5 * 10 + (c - 48);
                            c = ((++ptr < strEnd) ? (*ptr) : '\0');
                            if (num5 > 1000)
                            {
                                num5 = 9999;
                                while (c >= '0' && c <= '9')
                                {
                                    c = ((++ptr < strEnd) ? (*ptr) : '\0');
                                }
                            }
                        }
                        while (c >= '0' && c <= '9');
                        if (flag3)
                        {
                            num5 = -num5;
                        }
                        number.scale += num5;
                    }
                    else
                    {
                        ptr = ptr3;
                        c = ((ptr < strEnd) ? (*ptr) : '\0');
                    }
                }
                while (true)
                {
                    if (!IsWhite(c) || (options & NumberStyles.AllowTrailingWhite) == 0)
                    {
                        char* ptr2;
                        if ((options & NumberStyles.AllowTrailingSign) != 0 && (num & 1) == 0 && ((ptr2 = MatchChars(ptr, strEnd, numfmt.PositiveSign)) != null || ((ptr2 = MatchNegativeSignChars(ptr, strEnd, numfmt.NegativeSign, allowHyphenDuringParsing)) != null && (number.sign = true))))
                        {
                            num |= 1;
                            ptr = ptr2 - 1;
                        }
                        else if (c == ')' && ((uint)num & 2u) != 0)
                        {
                            num &= -3;
                        }
                        else
                        {
                            if (text == null || (ptr2 = MatchChars(ptr, strEnd, text)) == null)
                            {
                                break;
                            }
                            text = null;
                            ptr = ptr2 - 1;
                        }
                    }
                    c = ((++ptr < strEnd) ? (*ptr) : '\0');
                }
                if ((num & 2) == 0)
                {
                    if ((num & 8) == 0)
                    {
                        if (!parseDecimal)
                        {
                            number.scale = 0;
                        }
                        if ((num & 0x10) == 0)
                        {
                            number.sign = false;
                        }
                    }
                    str = ptr;
                    return true;
                }
            }
            str = ptr;
            return false;
        }

References System.Globalization.FormatProvider.Number.AllowHyphenDuringParsing(), System.Text.StringBuilder.Append(), System.Globalization.NumberFormatInfo.CurrencyDecimalSeparator, System.Globalization.NumberFormatInfo.CurrencyGroupSeparator, System.Globalization.NumberFormatInfo.CurrencySymbol, System.Globalization.FormatProvider.Number.IsWhite(), System.Globalization.FormatProvider.Number.MatchChars(), System.Globalization.FormatProvider.Number.MatchNegativeSignChars(), System.Globalization.NumberFormatInfo.NegativeSign, System.Globalization.NumberFormatInfo.NumberDecimalSeparator, System.Globalization.NumberFormatInfo.NumberGroupSeparator, System.Globalization.NumberFormatInfo.NumberNegativePattern, System.options, System.Globalization.NumberFormatInfo.PositiveSign, System.str, and System.text.

Referenced by System.Globalization.FormatProvider.Number.TryStringToNumber().