StringToDouble()

static unsafe double System.Xml.Xsl.XPathConvert.StringToDouble ( string s )

inlinestatic

Definition at line 1828 of file XPathConvert.cs.

    {
        fixed (char* ptr = s)
        {
            int num = 0;
            char* ptr2 = ptr;
            char* ptr3 = null;
            int num2 = 1;
            int num3 = 0;
            while (true)
            {
                char c = *(ptr2++);
                if (!IsAsciiDigit(c))
                {
                    if (c != '-')
                    {
                        if (c == '.')
                        {
                            if (IsAsciiDigit(*ptr2))
                            {
                                goto IL_00b8;
                            }
                        }
                        else if (IsWhitespace(c) && num2 > 0)
                        {
                            ptr2 = SkipWhitespace(ptr2);
                            continue;
                        }
                    }
                    else if (num2 >= 0)
                    {
                        num2 = -1;
                        continue;
                    }
                    return double.NaN;
                }
                if (c == '0')
                {
                    do
                    {
                        c = *(ptr2++);
                    }
                    while (c == '0');
                    if (!IsAsciiDigit(c))
                    {
                        goto IL_00b2;
                    }
                }
                ptr3 = ptr2 - 1;
                do
                {
                    c = *(ptr2++);
                }
                while (IsAsciiDigit(c));
                num = (int)(ptr2 - ptr3) - 1;
                goto IL_00b2;
                IL_00b8:
                c = *(ptr2++);
                if (ptr3 == null)
                {
                    while (c == '0')
                    {
                        num3--;
                        c = *(ptr2++);
                    }
                    ptr3 = ptr2 - 1;
                }
                while (IsAsciiDigit(c))
                {
                    num3--;
                    num++;
                    c = *(ptr2++);
                }
                break;
                IL_00b2:
                if (c != '.')
                {
                    break;
                }
                goto IL_00b8;
            }
            ptr2--;
            char* ptr4 = ptr + s.Length;
            if (ptr2 < ptr4 && SkipWhitespace(ptr2) < ptr4)
            {
                return double.NaN;
            }
            if (num == 0)
            {
                return 0.0;
            }
            if (num3 == 0 && num <= 9)
            {
                int num4 = *ptr3 & 0xF;
                while (--num != 0)
                {
                    ptr3++;
                    num4 = num4 * 10 + (*ptr3 & 0xF);
                }
                return (num2 < 0) ? (-num4) : num4;
            }
            if (num > 50)
            {
                ptr2 -= num - 50;
                num3 += num - 50;
                num = 50;
            }
            while (true)
            {
                if (*(--ptr2) == '0')
                {
                    num--;
                    num3++;
                }
                else if (*ptr2 != '.')
                {
                    break;
                }
            }
            ptr2++;
            FloatingDecimal floatingDecimal = new FloatingDecimal();
            floatingDecimal.Exponent = num3 + num;
            floatingDecimal.Sign = num2;
            floatingDecimal.MantissaSize = num;
            fixed (byte* ptr5 = &floatingDecimal.Mantissa[0])
            {
                byte* ptr6 = ptr5;
                for (; ptr3 < ptr2; ptr3++)
                {
                    if (*ptr3 != '.')
                    {
                        *ptr6 = (byte)(*ptr3 & 0xFu);
                        ptr6++;
                    }
                }
            }
            return (double)floatingDecimal;
        }
    }

References System.Xml.Dictionary, System.Xml.Xsl.XPathConvert.IsAsciiDigit(), System.Xml.Xsl.XPathConvert.IsWhitespace(), System.s, and System.Xml.Xsl.XPathConvert.SkipWhitespace().

Referenced by System.Xml.Xsl.Xslt.QilGenerator.CompileGroupingSizeAttribute(), System.Xml.Xsl.Xslt.XsltLoader.LoadTemplate(), System.Xml.Xsl.XPath.XPathParser< Node >.ParsePrimaryExpr(), System.Xml.Xsl.Xslt.XsltInput.SetVersion(), System.Xml.Xsl.Runtime.XsltConvert.ToDouble(), and System.Xml.Xsl.Runtime.XsltConvert.ToDouble().