Changeset 1747

Timestamp:

07/12/10 00:48:49 (14 years ago)

Author:

andrei

Message:

Fixed http://d.puremagic.com/issues/show_bug.cgi?id=2971

Files:

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

trunk/phobos/std/conv.d

@@ -1 +1 @@
-// Written in the D programming language.
-
-/**
-A one-stop shop for converting values from one type to another.
-
- - 2009
+-
-
-License:   $(WEB boost.org/LICENSE_1_0.txt, Boost License 1.0).
-
-Authors:   $(WEB digitalmars.com, Walter Bright),
-           $(WEB erdani.org, Andrei Alexandrescu),
-           Shin Fujishiro,
-           Adam D. Ruppe
-
-
-
-
-
+
-*/
-module std.conv;
-
-import core.stdc.math : ldexpl;
-import core.memory, core.stdc.errno, core.stdc.string,
-    core.stdc.stdlib;
-rray, std.ctype, std.exception, std.math, std.range, std.stdio
-
+lgorithm, std.array, std.ctype, std.exception, std.math, std.range
+dio, std.st
-import std.metastrings;
-
-//debug=conv;           // uncomment to turn on debugging printf's
-
-/* ************* Exceptions *************** */
-
-/**
- * Thrown on conversion errors.
- */
-class ConvError : Error
-{
-    this(string s)
-    {
-        super(s);
-    }
-
-
-
-
-
-
-
-
-
-
+
+
+
-{
-    throw new ConvError(cast(string)
-            ("std.conv("~to!string(ln)
-                    ~"): Can't convert value `"~to!(string)(source)~"' of type "
-                    ~S.stringof~" to type "~T.stringof));
-}
-
-/**
- * Thrown on conversion overflow errors.
- */
@@ -76 +66 @@
-private template implicitlyConverts(S, T)
-{
-    enum bool implicitlyConverts = T.sizeof >= S.sizeof
-        && is(typeof({S s; T t = s;}()));
-}
-
-unittest
-{
-    assert(!implicitlyConverts!(const(char)[], string));
-    assert(implicitlyConverts!(string, const(char)[]));
+}
+
+/**
+   Entry point that dispatches to the appropriate conversion
+   primitive. Client code normally calls $(D _to!TargetType(value))
+   (and not some variant of $(D toImpl)).
+ */
+template to(T)
+{
+    T to(A...)(A args) { return toImpl!T(args); }
-}
-
-/**
-String _to string conversion works for any two string types having
-($(D char), $(D wchar), $(D dchar)) character widths and any
-combination of qualifiers (mutable, $(D const), or $(D immutable)).
-
-Example:
-----
-char[] a = "abc";
-auto b = to!(immutable(dchar)[])(a);
-assert(b == "abc"w);
-----
- */
-
+Impl
-        && isSomeString!(S))
-{
-    // string-to-string conversion
-    static if (s[0].sizeof == T[0].sizeof) {
-        // same width, only qualifier conversion
-        enum tIsConst = is(T == const(char)[]) || is(T == const(wchar)[])
-            || is(T == const(dchar)[]);
-        enum tIsInvariant = is(T == immutable(char)[])
-            || is(T == immutable(wchar)[]) || is(T == immutable(dchar)[]);
-        static if (tIsConst) {
@@ -137 +137 @@
-    {
-        alias TypeTuple!(LhsC[], const(LhsC)[], immutable(LhsC)[]) LhStrings;
-        foreach (Lhs; LhStrings)
-        {
-            foreach (RhsC; Chars)
-            {
-                alias TypeTuple!(RhsC[], const(RhsC)[], immutable(RhsC)[])
-                    RhStrings;
-                foreach (Rhs; RhStrings)
-                {
-(Lhs)
-(Rhs)
+Lhs
+Rhs
-                    //writeln(Lhs.stringof, " -> ", Rhs.stringof);
-(Lhs)
+Lhs
-                }
-            }
-        }
-    }
-}
-
-/**
-Converts array (other than strings) to string. The left bracket,
-separator, and right bracket are configurable. Each element is
-converted by calling $(D to!T).
- */
-
+Impl
-    in T rightBracket = "]")
-if (isSomeString!(T) && !isSomeString!(S) && isArray!(S))
-{
-    alias Unqual!(typeof(T.init[0])) Char;
-    // array-to-string conversion
-    static if (is(S == void[])
-            || is(S == const(void)[]) || is(S == immutable(void)[])) {
-        auto raw = cast(const(ubyte)[]) s;
-        enforce(raw.length % Char.sizeof == 0, "Alignment mismatch"
-                " in converting a " ~ S.stringof ~ " to a " ~ T.stringof);
@@ -194 +194 @@
-    double[2] a = [ 1.5, 2.5 ];
-    //writeln(to!string(a));
-    assert(to!string(a) == "[1.5 2.5]");
-}
-
-/**
-Associative array to string conversion. The left bracket, key-value
-separator, element separator, and right bracket are configurable.
-Each element is printed by calling $(D to!T).
- */
-
+Impl
-        in T separator = ", ", in T rightBracket = "]")
-if (isAssociativeArray!(S) && isSomeString!(T))
-{
-    alias Unqual!(typeof(T.init[0])) Char;
-    auto result = appender!(Char[])();
-    // hash-to-string conversion
-    result.put(leftBracket);
-    bool first = true;
-    foreach (k, v; s) {
-        if (!first) result.put(separator);
@@ -218 +218 @@
-        result.put(to!(T)(v));
-    }
-    result.put(rightBracket);
-    return cast(T) result.data;
-}
-
-/**
-Object to string conversion calls $(D toString) against the object or
-returns $(D nullstr) if the object is null.
- */
-
+Impl
-if (is(S : Object) && isSomeString!(T))
-{
-    if (!s) return nullstr;
-    return to!(T)(s.toString);
-}
-
-unittest
-{
-    class A { override string toString() { return "an A"; } }
-    A a;
-    assert(to!string(a) == "null");
-    a = new A;
-    assert(to!string(a) == "an A");
-}
-
-/**
-Struct to string conversion calls $(D toString) against the struct if
-it is defined.
- */
-
+Impl
-if (is(S == struct) && isSomeString!(T) && is(typeof(&S.init.toString)))
-{
-    return to!T(s.toString);
-}
-
-unittest
-{
-    struct S { string toString() { return "wyda"; } }
-    assert(to!string(S()) == "wyda");
-}
-
-/**
-For structs that do not define $(D toString), the conversion to string
-produces the list of fields.
- */
-
+Impl
-        in T right = ")")
-if (is(S == struct) && isSomeString!(T) && !is(typeof(&S.init.toString)))
-{
-    Tuple!(FieldTypeTuple!(S)) * t = void;
-    static if ((*t).sizeof == S.sizeof)
-    {
-        // ok, attempt to forge the tuple
-        t = cast(typeof(t)) &s;
-        alias Unqual!(typeof(T.init[0])) Char;
-        auto app = appender!(Char[])();
@@ -291 +291 @@
-unittest
-{
-    struct S { int a = 42; float b = 43.5; }
-    S s;
-    assert(to!string(s) == "S(42, 43.5)");
-}
-
-/**
-Enumerated types are converted to strings as their symbolic names.
- */
-
+Impl
-        && !implicitlyConverts!(S, T))
-{
-    mixin (enumToStringImpl!(S).code);
-}
-
-// internal
-private template enumToStringImpl(Enum)
-{
-    template generate(alias members)
-    {
@@ -344 +344 @@
-        assert(0);
-    }
-    catch (ConvError e)
-    {
-    }
-}
-
-/**
-A $(D typedef Type Symbol) is converted to string as $(D "Type(value)").
- */
-
+Impl
-if (is(S == typedef) && isSomeString!(T))
-{
-    static if (is(S Original == typedef)) {
-        // typedef
-        return left ~ to!(T)(cast(Original) s) ~ right;
-    }
-}
-
-unittest
-{
@@ -489 +489 @@
-conversion might throw an exception because $(D_PARAM to!(short))
-might fail the range check.
-
-Macros: WIKI=Phobos/StdConv
- */
-
-/**
-If the source type is implicitly convertible to the target type, $(D
-to) simply performs the implicit conversion.
- */
-
+Impl
-{
-    return value;
-}
-
-unittest
-{
-    int a = 42;
-    auto b = to!long(a);
-    assert(a == b);
-}
-
-/**
-Boolean values are printed as $(D "true") or $(D "false").
- */
-
+Impl
-{
-    return to!T(b ? "true" : "false");
-}
-
-unittest
-{
-    bool b;
-    assert(to!string(b) == "false");
-    b = true;
-    assert(to!string(b) == "true");
-}
-
-
-/**
-When the source is a wide string, it is first converted to a narrow
-string and then parsed.
- */
-
+Impl
-        && !isSomeString!(T))
-{
-    // todo: improve performance
-    return parseString!(T)(toUTF8(value));
-}
-
-/**
-When the source is a narrow string, normal text parsing occurs.
- */
-
+Impl
-{
-    return parseString!(T)(value);
-}
-
-unittest
-{
-    foreach (Char; TypeTuple!(char, wchar, dchar))
-    {
-        auto a = to!(Char[])("123");
-        assert(to!int(a) == 123);
-        assert(to!double(a) == 123);
-    }
-}
-
-/**
-Object-to-object conversions throw exception when the source is
-non-null and the target is null.
- */
-
+Impl
-{
-    auto result = cast(T) value;
-    if (!result && value)
-    {
-        throw new ConvError("Cannot convert object of static type "
-                ~S.classinfo.name~" and dynamic type "~value.classinfo.name
-                ~" to type "~T.classinfo.name);
-    }
-    return result;
-}
@@ -603 +603 @@
-    ...
-}
-
-unittest
-{
-    auto d = new Date;
-    auto ts = to!long(d); // same as d.to!long()
-}
-----
- */
-
+Impl
-        && is(typeof(S.init.to!(T)()) : T))
-{
-    return value.to!T();
-}
-
-unittest
-{
-    class B { T to(T)() { return 43; } }
-    auto b = new B;
-    assert(to!int(b) == 43);
-}
-
-/**
-Narrowing numeric-numeric conversions throw when the value does not
-fit in the narrower type.
- */
-
+Impl
-if (!implicitlyConverts!(S, T)
-        && std.traits.isNumeric!(S) && std.traits.isNumeric!(T))
-{
-    enum sSmallest = mostNegative!(S);
-    enum tSmallest = mostNegative!(T);
-    static if (sSmallest < 0) {
-        // possible underflow converting from a signed
-        static if (tSmallest == 0) {
-            immutable good = value >= 0;
-        } else {
@@ -649 +649 @@
-    }
-    return cast(T) value;
-}
-
-private T parseString(T)(const(char)[] v)
-{
-    scope(exit)
-    {
-        if (v.length)
-        {
-_e
+E
-        }
-    }
-    return parse!(T)(v);
-}
-
-/**
-Array-to-array conversion (except when target is a string type)
-converts each element in turn by using $(D to).
- */
-
+Impl
-        && !implicitlyConverts!(S, T))
-{
-    alias typeof(T.init[0]) E;
-    auto result = new E[src.length];
-    foreach (i, e; src) {
-    /* Temporarily cast to mutable type, so we can get it initialized,
-     * this is ok because there are no other references to result[]
-     */
-        cast()(result[i]) = to!(E)(e);
-    }
@@ -693 +693 @@
-    assert(b == [ 1.0f, 2, 3 ]);
-    uint[][] e = [ a, a ];
-    auto f = to!(float[][])(e);
-    assert(f[0] == b && f[1] == b);
-}
-
-/**
-Associative array to associative array conversion converts each key
-and each value in turn.
- */
-
+Impl
-if (isAssociativeArray!(S) && isAssociativeArray!(T))
-{
-    alias typeof(T.keys[0]) K2;
-    alias typeof(T.values[0]) V2;
-    T result;
-    foreach (k1, v1; src)
-    {
-        result[to!(K2)(k1)] = to!(V2)(v1);
-    }
-    return result;
@@ -960 +960 @@
-Target parse(Target, Source)(ref Source s)
-if (isSomeChar!(ElementType!Source) && isIntegral!Target)
-{
-    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)
-        {
-_e
+E
-        }
-        return result;
-    }
-    else
-    {
-        // Larger than int types
-        // immutable length = s.length;
-        // if (!length)
-        //     goto Lerr;
-        if (s.empty) goto Lerr;
@@ -1026 +1026 @@
-        {
-            if (sign == -1)
-            {
-                v = -v;
-            }
-        }
-        return v;
-      Loverflow:
-        ConvOverflowError.raise("Overflow in integral conversion");
-      Lerr:
-_e
+E
-        return 0;
-    }
-}
-
-Target parse(Target, Source)(ref Source s)
-if (isSomeString!Source && is(Target == enum))
-{
-    mixin(enumFromStringImpl!Target.code);
-}
-
@@ -1401 +1401 @@
-    if (s.length >= 4 && icmp(s[0 .. 4], "true")==0)
-    {
-        s = s[4 .. $];
-        return true;
-    }
-    if (s.length >= 5 && icmp(s[0 .. 5], "false")==0)
-    {
-        s = s[5 .. $];
-        return false;
-    }
-_e
+E
-    assert(0);
-}
-
-
-// Parsing typedefs forwards to their host types
-Target parse(Target, Source)(ref Source s)
-if (isSomeString!Source && is(Target == typedef))
-{
-    static if (is(Target T == typedef))
-        return cast(Target) parse!T(s);
@@ -2468 +2468 @@
-        // incorrectly.
-        //if (cf > cfloat.max)
-        //    goto Loverflow;
-
-        return cf;
-
-      Loverflow:
-        conv_overflow(s);
-
-      Lerr:
-_e
+E
-        return cast(cfloat)0.0e-0+0i;
-    }
-
-    unittest
-    {
-        debug(conv) writefln("conv.toCfloat.unittest");
-        cfloat cf;
-
-        cf = toCfloat(to!string("1.2345e-5+0i"));
-        assert(to!string(cf) == to!string(1.2345e-5+0i));
@@ -2543 +2543 @@
-        //Disabled, waiting on a bug fix.
-        //if (cd > cdouble.max)  //same problem the toCfloat() having
-        //    goto Loverflow;
-
-        return cd;
-
-      Loverflow:
-        conv_overflow(s);
-
-      Lerr:
-_e
+E
-        return cast(cdouble)0.0e-0+0i;
-    }
-
-    unittest
-    {
-        debug(conv) writefln("conv.toCdouble.unittest");
-        cdouble cd;
-
-        cd = toCdouble(to!string("1.2345e-5+0i"));
-        assert(to!string( cd ) == to!string(1.2345e-5+0i));
@@ -2619 +2619 @@
-        if (s1 =="nan" && s2 == "nani")
-            cr = creal.nan;
-        else if (r2 != 0.0)
-            cr = cast(creal)(r1 + (r2 * 1.0i));
-        else
-            cr = cast(creal)(r1 + 0.0i);
-
-        return cr;
-
-      Lerr:
-_e
+E
-        return cast(creal)0.0e-0+0i;
-    }
-
-    unittest
-    {
-        debug(conv) writefln("conv.toCreal.unittest");
-        creal cr;
-
-        cr = toCreal(to!string("1.2345e-5+0i"));
-        assert(to!string(cr) == to!string(1.2345e-5+0i));
@@ -2805 +2805 @@
-    if (isnan(r1a))
-        return cast(bool)isnan(r2b);
-
-    if (isnan(r2b))
-        return 0;
-
-    return feq(r1a, r2b, 0.000001L);
-}
-
-/// Small unsigned integers to strings.
-
+Impl
-        && S.sizeof < uint.sizeof && isSomeString!T)
-{
-    return to!T(cast(uint) value);
-}
-
-/// Small signed integers to strings.
-
+Impl
-        && S.sizeof < int.sizeof && isSomeString!T)
-{
-    return to!T(cast(int) value);
-}
-
-/// Unsigned integers (uint and ulong) to string.
-
+Impl
-if (staticIndexOf!(Unqual!S, uint, ulong) >= 0 && isSomeString!T)
-{
-    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";
@@ -2874 +2874 @@
-}
-
-unittest
-{
-    assert(wtext(int.max) == "2147483647"w);
-    assert(wtext(int.min) == "-2147483648"w);
-    assert(to!string(0L) == "0");
-}
-
-/// $(D char), $(D wchar), $(D dchar) to a string type.
-
+Impl
-        && isSomeString!(T))
-{
-    alias typeof(T.init[0]) Char;
-    static if (Char.sizeof >= S.sizeof)
-    {
-        return [ c ];
-    }
-    else
-    {
-        Unqual!Char[] result;
@@ -2911 +2911 @@
-        {
-            Char1 c = 'a';
-            assert(to!(Char2[])(c)[0] == c);
-        }
-        uint x = 4;
-        assert(to!(Char1[])(x) == "4");
-    }
-}
-
-/// Signed values ($(D int) and $(D long)).
-
+Impl
-if (staticIndexOf!(Unqual!S, int, long) >= 0 && isSomeString!T)
-{
-    if (value >= 0)
-        return to!T(cast(Unsigned!(S)) value);
-    alias Unqual!(typeof(T.init[0])) Char;
-
-    // Cache read-only data only for const and immutable - mutable
-    // data is supposed to use allocation in all cases
-    static if (is(ElementType!T == const) || is(ElementType!T == immutable))
-    {
@@ -2982 +2982 @@
-    r = to!string(-123L);
-    i = cmp(r, "-123");
-    assert(i == 0);
-
-    const h  = 6;
-    string s = to!string(h);
-    assert(s == "6");
-}
-
-/// C-style strings
-
+Impl
-{
-    return s ? cast(T) s[0 .. strlen(s)].dup : cast(string)null;
-}
-
-/// $(D float) to all string types.
-
+Impl
-{
-    return to!T(cast(double) f);
-}
-
-/// $(D double) to all string types.
-
+Impl
-{
-    //alias Unqual!(ElementType!T) Char;
-    char[20] buffer;
-    int len = sprintf(buffer.ptr, "%g", d);
-    return to!T(buffer[0 .. len].dup);
-}
-
-/// $(D real) to all string types.
-
+Impl
-{
-    char[20] buffer;
-    int len = sprintf(buffer.ptr, "%Lg", r);
-    return to!T(buffer[0 .. len].dup);
-}
-
-/// $(D ifloat) to all string types.
-
+Impl
-{
-    return to!T(cast(idouble) f);
-}
-
-/// $(D idouble) to all string types.
-
+Impl
-{
-    char[21] buffer;
-    int len = sprintf(buffer.ptr, "%gi", d);
-    return to!T(buffer[0 .. len].dup);
-}
-
-/// $(D ireal) to all string types.
-
+Impl
-{
-    char[21] buffer;
-    int len = sprintf(buffer.ptr, "%Lgi", r);
-    //assert(len < buffer.length); // written bytes is len + 1
-    return to!T(buffer[0 .. len].dup);
-}
-
-/// $(D cfloat) to all string types.
-
+Impl
-{
-    return to!string(cast(cdouble) f);
-}
-
-/// $(D cdouble) to all string types.
-
+Impl
-{
-    char[20 + 1 + 20 + 1] buffer;
-
-    int len = sprintf(buffer.ptr, "%g+%gi", d.re, d.im);
-    return to!T(buffer[0 .. len]);
-}
-
-/// $(D creal) to all string types.
-
+Impl
-{
-    char[20 + 1 + 20 + 1] buffer;
-    int len = sprintf(buffer.ptr, "%Lg+%Lgi", r.re, r.im);
-    return to!T(buffer[0 .. len].dup);
-}
-
-/******************************************
- * 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.
- */
-
+Impl
-if (isIntegral!(Unqual!S) && !is(Unqual!S == ulong) && isSomeString!(T))
-{
-    enforce(radix >= 2 && radix <= 36);
-    if (radix == 10)
-        return to!string(value);     // handle signed cases only for radix 10
-    return to!string(cast(ulong) value, radix);
-}
-
-/// ditto
-
+Impl
-if (is(Unqual!S == ulong) && isSomeString!(T))
-in
-{
-    assert(radix >= 2 && radix <= 36);
-}
-body
-{
-    char[value.sizeof * 8] buffer;
-    uint i = buffer.length;
-
@@ -3335 +3335 @@
-    assert(i == 0);
-
-    r = to!string(123u);
-    i = cmp(r, "123");
-    assert(i == 0);
-}
-
-/**
-Pointer to string conversions prints the pointer as a $(D size_t) value.
- */
-
+Impl
-if (isPointer!S && !isSomeChar!(typeof(*S.init)) && isSomeString!T)
-{
-    return to!T(cast(size_t) value, 16u);
-}
-
-private S textImpl(S, U...)(U args)
-{
-    S result;
-    foreach (i, arg; args)
-    {
@@ -3613 +3613 @@
-
-    // this should pass, but it doesn't, since the int converter
-    // doesn't pass along its suffix to helper templates
-
-    //static assert(!__traits(compiles, a = octal!1L));
-
-    static assert(__traits(compiles, b = octal!"1L"));
-    static assert(__traits(compiles, b = octal!1L));
-}
-
-
+Impl
-{
-    return T(src);
-}
-
-// Bugzilla 3961
-unittest
-{
-    struct Int { int x; }
-    Int i = to!Int(1);
-}
@@ -3698 +3698 @@
-        double x = 5, y = 6;
-        this(int a, int b) { assert(x == 5 && y == 6); x = a; y = b; }
-    }
-
-    auto s1 = new void[S.sizeof];
-    auto s2 = S(42, 43);
-    assert(*emplace!S(s1, s2) == s2);
-    assert(*emplace!S(s1, 44, 45) == S(44, 45));
-}
-
+unittest
+{
+    // Check fix for http://d.puremagic.com/issues/show_bug.cgi?id=2971
+    assert(equal(map!(to!int)(["42", "34", "345"]), [42, 34, 345]));
+}
+