TryParseNumber()

static unsafe bool System.Number.TryParseNumber ( ref char * str, char * strEnd, NumberStyles styles, ref NumberBuffer number, NumberFormatInfo info )

inlinestaticprivate

Definition at line 4041 of file Number.cs.

    {
        string text = null;
        bool flag = false;
        string value;
        string value2;
        if ((styles & NumberStyles.AllowCurrencySymbol) != 0)
        {
            text = info.CurrencySymbol;
            value = info.CurrencyDecimalSeparator;
            value2 = info.CurrencyGroupSeparator;
            flag = true;
        }
        else
        {
            value = info.NumberDecimalSeparator;
            value2 = info.NumberGroupSeparator;
        }
        int num = 0;
        char* ptr = str;
        char c = ((ptr < strEnd) ? (*ptr) : '\0');
        while (true)
        {
            if (!IsWhite(c) || (styles & NumberStyles.AllowLeadingWhite) == 0 || (((uint)num & (true ? 1u : 0u)) != 0 && (num & 0x20) == 0 && info.NumberNegativePattern != 2))
            {
                char* ptr2;
                if ((styles & NumberStyles.AllowLeadingSign) != 0 && (num & 1) == 0 && ((ptr2 = MatchChars(ptr, strEnd, info.PositiveSign)) != null || ((ptr2 = MatchNegativeSignChars(ptr, strEnd, info)) != null && (number.IsNegative = true))))
                {
                    num |= 1;
                    ptr = ptr2 - 1;
                }
                else if (c == '(' && (styles & NumberStyles.AllowParentheses) != 0 && (num & 1) == 0)
                {
                    num |= 3;
                    number.IsNegative = 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 num2 = 0;
        int num3 = 0;
        int num4 = number.Digits.Length - 1;
        int num5 = 0;
        while (true)
        {
            char* ptr2;
            if (IsDigit(c))
            {
                num |= 4;
                if (c != '0' || ((uint)num & 8u) != 0)
                {
                    if (num2 < num4)
                    {
                        number.Digits[num2] = (byte)c;
                        if (c != '0' || number.Kind != NumberBufferKind.Integer)
                        {
                            num3 = num2 + 1;
                        }
                    }
                    else if (c != '0')
                    {
                        number.HasNonZeroTail = true;
                    }
                    if ((num & 0x10) == 0)
                    {
                        number.Scale++;
                    }
                    if (num2 < num4)
                    {
                        num5 = ((c == '0') ? (num5 + 1) : 0);
                    }
                    num2++;
                    num |= 8;
                }
                else if (((uint)num & 0x10u) != 0)
                {
                    number.Scale--;
                }
            }
            else if ((styles & NumberStyles.AllowDecimalPoint) != 0 && (num & 0x10) == 0 && ((ptr2 = MatchChars(ptr, strEnd, value)) != null || (flag && (num & 0x20) == 0 && (ptr2 = MatchChars(ptr, strEnd, info.NumberDecimalSeparator)) != null)))
            {
                num |= 0x10;
                ptr = ptr2 - 1;
            }
            else
            {
                if ((styles & NumberStyles.AllowThousands) == 0 || (num & 4) == 0 || ((uint)num & 0x10u) != 0 || ((ptr2 = MatchChars(ptr, strEnd, value2)) == null && (!flag || ((uint)num & 0x20u) != 0 || (ptr2 = MatchChars(ptr, strEnd, info.NumberGroupSeparator)) == null)))
                {
                    break;
                }
                ptr = ptr2 - 1;
            }
            c = ((++ptr < strEnd) ? (*ptr) : '\0');
        }
        bool flag2 = false;
        number.DigitsCount = num3;
        number.Digits[num3] = 0;
        if (((uint)num & 4u) != 0)
        {
            if ((c == 'E' || c == 'e') && (styles & NumberStyles.AllowExponent) != 0)
            {
                char* ptr3 = ptr;
                c = ((++ptr < strEnd) ? (*ptr) : '\0');
                char* ptr2;
                if ((ptr2 = MatchChars(ptr, strEnd, info._positiveSign)) != null)
                {
                    c = (((ptr = ptr2) < strEnd) ? (*ptr) : '\0');
                }
                else if ((ptr2 = MatchNegativeSignChars(ptr, strEnd, info)) != null)
                {
                    c = (((ptr = ptr2) < strEnd) ? (*ptr) : '\0');
                    flag2 = true;
                }
                if (IsDigit(c))
                {
                    int num6 = 0;
                    do
                    {
                        num6 = num6 * 10 + (c - 48);
                        c = ((++ptr < strEnd) ? (*ptr) : '\0');
                        if (num6 > 1000)
                        {
                            num6 = 9999;
                            while (IsDigit(c))
                            {
                                c = ((++ptr < strEnd) ? (*ptr) : '\0');
                            }
                        }
                    }
                    while (IsDigit(c));
                    if (flag2)
                    {
                        num6 = -num6;
                    }
                    number.Scale += num6;
                }
                else
                {
                    ptr = ptr3;
                    c = ((ptr < strEnd) ? (*ptr) : '\0');
                }
            }
            if (number.Kind == NumberBufferKind.FloatingPoint && !number.HasNonZeroTail)
            {
                int num7 = num3 - number.Scale;
                if (num7 > 0)
                {
                    num5 = Math.Min(num5, num7);
                    number.DigitsCount = num3 - num5;
                    number.Digits[number.DigitsCount] = 0;
                }
            }
            while (true)
            {
                if (!IsWhite(c) || (styles & NumberStyles.AllowTrailingWhite) == 0)
                {
                    char* ptr2;
                    if ((styles & NumberStyles.AllowTrailingSign) != 0 && (num & 1) == 0 && ((ptr2 = MatchChars(ptr, strEnd, info.PositiveSign)) != null || ((ptr2 = MatchNegativeSignChars(ptr, strEnd, info)) != null && (number.IsNegative = 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 (number.Kind != NumberBufferKind.Decimal)
                    {
                        number.Scale = 0;
                    }
                    if (number.Kind == NumberBufferKind.Integer && (num & 0x10) == 0)
                    {
                        number.IsNegative = false;
                    }
                }
                str = ptr;
                return true;
            }
        }
        str = ptr;
        return false;
    }

References System.info, System.Number.IsDigit(), System.Number.IsWhite(), System.Number.MatchChars(), System.Number.MatchNegativeSignChars(), System.Math.Min(), System.str, System.text, and System.value.

Referenced by System.Number.TryStringToNumber().