Changeset 1717

Timestamp:

07/04/10 21:39:09 (14 years ago)

Author:

andrei

Message:

Changed parse for integrals to accept input ranges; adapted Walter's strtold implementation to input ranges.

Files:

• trunk/phobos/std/conv.d (modified) (6 diffs)

trunk/phobos/std/conv.d

@@ -12 +12 @@
-           Shin Fujishiro,
-           Adam D. Ruppe
-
-         Copyright Digital Mars 2007 - 2009.
-Distributed under the Boost Software License, Version 1.0.
-   (See accompanying file LICENSE_1_0.txt or copy at
-         http://www.boost.org/LICENSE_1_0.txt)
-*/
-module std.conv;
-
-memory, core.stdc.errno, core.stdc.string, core.stdc.stdlib,
-    std.array, std.contracts
-std.ctype, std.math, std.range, std.stdio,
-    std.string, std.traits, std.typecons, std.typetuple
-
+stdc.math : ldexpl;
+import core.memory, core.stdc.errno, core.stdc.string
+core.stdc.stdlib;
+import std.array, std.ctype, std.exception, std.math, std.range, std.stdio
+string, std.traits, std.typecons, std.typetuple, std.
-import std.metastrings;
-
-//debug=conv;           // uncomment to turn on debugging printf's
-
-/* ************* Exceptions *************** */
-
-/**
- * Thrown on conversion errors.
- */
-class ConvError : Error
@@ -951 +951 @@
-assert(test == " \t  76.14"); // parse bumps string
-munch(test, " \t\n\r"); // skip ws
-assert(test == "76.14");
-auto b = parse!(double)(test);
-assert(b == 76.14);
-assert(test == "");
---------------
- */
-
-Target parse(Target, Source)(ref Source s)
-String!Source
+Char!(ElementType!Source)
-{
-    static if (Target.sizeof < int.sizeof)
-    {
-        // smaller types are handled like integers
-        auto v = parse!(Select!(Target.min < 0, int, uint), Source)(s);
-        auto result = cast(Target) v;
-        if (result != v)
-        {
-            conv_error!(Source, Target)(s);
-        }
-        return result;
-    }
-    else
-    {
-        // Larger than int types
-
-
-
+
+
+
+
-
-        static if (Target.min < 0)
-            int sign = 0;
-        else
-            static const int sign = 0;
-        Target v = 0;
-        size_t i = 0;
-        enum char maxLastDigit = Target.min < 0 ? '7' : '5';
-
-
-
+
+
+
+
+
-            if (c >= '0' && c <= '9')
-            {
-                if (v >= Target.max/10 &&
-                        (v != Target.max/10|| c + sign > maxLastDigit))
-                    goto Loverflow;
-                v = cast(Target) (v * 10 + (c - '0'));
+                s.popFront();
-            }
-            else static if (Target.min < 0)
-            {
-                if (c == '-' && i == 0)
-                {
-
+
+
-                        goto Lerr;
-                    sign = -1;
-                }
-                else if (c == '+' && i == 0)
-                {
-
+
+
-                        goto Lerr;
-                }
-                else
-                    break;
-            }
-            else
-                break;
-        }
-        if (i == 0) goto Lerr;
-
+//
-        static if (Target.min < 0)
-        {
-            if (sign == -1)
-            {
-                v = -v;
-            }
-        }
-        return v;
-      Loverflow:
-        ConvOverflowError.raise("Overflow in integral conversion");
@@ -1076 +1082 @@
-    try
-    {
-        to!E("d");
-        assert(0);
-    }
-    catch (ConvError e)
-    {
-    }
-}
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
-unittest
-{
-    string s = "123";
-    auto a = parse!int(s);
-}
-
-
-// string to bool conversions
-Target parse(Target, Source)(ref Source s)
@@ -2613 +2820 @@
-
-/// Small signed integers to strings.
-T to(T, S)(S value) if (isIntegral!S && S.min < 0
-        && S.sizeof < int.sizeof && isSomeString!T)
-{
-    return to!T(cast(int) value);
-}
-
-/// Unsigned integers (uint and ulong) to string.
-T to(T, S)(S input)
-d.typetuple.st
+
-{
-    Unqual!S value = input;
-    alias Unqual!(typeof(T.init[0])) Char;
-    static if (is(typeof(T.init[0]) == const) ||
-            is(typeof(T.init[0]) == immutable))
-    {
-        if (value < 10)
-        {
-            static immutable Char[10] digits = "0123456789";
-            // Avoid storage allocation for simple stuff
@@ -2635 +2842 @@
-        }
-    }
-
-    static if (S.sizeof == uint.sizeof)
-        enum maxlength = S.sizeof * 3;
-    else
-        auto maxlength = (value > uint.max ? S.sizeof : uint.sizeof) * 3;
-
-    Char[] result;
-    if (__ctfe)
+    {
-        result = new Char[maxlength];
+    }
-    else
+    {
-        result = cast(Char[])
-            GC.malloc(Char.sizeof * maxlength, GC.BlkAttr.NO_SCAN)
-            [0 .. Char.sizeof * maxlength];
+    }
-
-    uint ndigits = 0;
-    do
-    {
-
-
-
+
+
+
+
+
-        result[$ - ndigits] = c;
-    }
-    while (value);
-    return cast(T) result[$ - ndigits .. $];
-}
-
-unittest
-{
-    assert(wtext(int.max) == "2147483647"w);
-    assert(wtext(int.min) == "-2147483648"w);
@@ -2852 +3065 @@
-
-/******************************************
- * Convert value to string in _radix radix.
- *
- * radix must be a value from 2 to 36.
- * value is treated as a signed value only if radix is 10.
- * The characters A through Z are used to represent values 10 through 36.
- */
-T to(T, S)(S value, uint radix)
-if (isIntegral!(Unqual!S) && !is(Unqual!S == ulong) && isSomeString!(T))
-
-
-
-
-
-
+
+
-    if (radix == 10)
-        return to!string(value);     // handle signed cases only for radix 10
-    return to!string(cast(ulong) value, radix);
-}
-
-/// ditto
-T to(T, S)(S value, uint radix)
-if (is(Unqual!S == ulong) && isSomeString!(T))
-in
-{