/** * String manipulation and comparison utilities. * * Copyright: Copyright Sean Kelly 2005 - 2009. * License:   $(HTTP www.boost.org/LICENSE_1_0.txt, Boost License 1.0). * Authors:   Sean Kelly, Walter Bright * Source: $(DRUNTIMESRC core/internal/_string.d) */ module core.internal.string; pure:nothrow:@nogc:@safe: alias UnsignedStringBuf = char[64]; /**Converts an unsigned integer value to a string of characters. Can be used when compiling with -betterC. Does not allocate memory. Params:    T = char, wchar or dchar    value = the unsigned integer value to convert    buf   = the pre-allocated buffer used to store the result    radix = the numeric base to use in the conversion 2 through 36 (defaults to 10)    upperCase = use upper case letters for radices 11 - 36 Returns:    The unsigned integer value as a string of characters*/T[] unsignedToTempString(uint radix = 10, bool upperCase = false, T)(ulong value, return scope T[] buf)if (radix >= 2 && radix <= 36 &&    (is(T == char) || is(T == wchar) || is(T == dchar))){    enum baseChar = upperCase ? 'A' : 'a';    size_t i = buf.length;     static if (size_t.sizeof == 4) // 32 bit CPU    {        if (value <= uint.max)        {            // use faster 32 bit arithmetic            uint val = cast(uint) value;            do            {                uint x = void;                if (val < radix)                {                    x = cast(uint)val;                    val = 0;                }                else                {                    x = cast(uint)(val % radix);                    val /= radix;                }                buf[--i] = cast(char)((radix <= 10 || x < 10) ? x + '0' : x - 10 + baseChar);            } while (val);            return buf[i .. $];        }    }     do    {        uint x = void;        if (value < radix)        {            x = cast(uint)value;            value = 0;        }        else        {            x = cast(uint)(value % radix);            value /= radix;        }        buf[--i] = cast(char)((radix <= 10 || x < 10) ? x + '0' : x - 10 + baseChar);    } while (value);    return buf[i .. $];} private struct TempStringNoAlloc(ubyte N){    private char[N] _buf = void;    private ubyte _len;    inout(char)[] get() inout return    {        return _buf[$-_len..$];    }    alias get this;} /**Converts an unsigned integer value to a string of characters. This implementation is a template so it can be used when compiling with -betterC. Params:    value = the unsigned integer value to convert    radix = the numeric base to use in the conversion (defaults to 10) Returns:    The unsigned integer value as a string of characters*/auto unsignedToTempString(uint radix = 10)(ulong value){    // Need a buffer of 65 bytes for radix of 2 with room for    // signedToTempString to possibly add a negative sign.    enum bufferSize = radix >= 10 ? 20 : 65;    TempStringNoAlloc!bufferSize result = void;    result._len = unsignedToTempString!radix(value, result._buf).length & 0xff;    return result;} unittest{    UnsignedStringBuf buf = void;    assert(0.unsignedToTempString(buf) == "0");    assert(1.unsignedToTempString(buf) == "1");    assert(12.unsignedToTempString(buf) == "12");    assert(0x12ABCF .unsignedToTempString!16(buf) == "12abcf");    assert(0x12ABCF .unsignedToTempString!(16, true)(buf) == "12ABCF");    assert(long.sizeof.unsignedToTempString(buf) == "8");    assert(uint.max.unsignedToTempString(buf) == "4294967295");    assert(ulong.max.unsignedToTempString(buf) == "18446744073709551615");     // use stack allocated struct version    assert(0.unsignedToTempString == "0");    assert(1.unsignedToTempString == "1");    assert(12.unsignedToTempString == "12");    assert(0x12ABCF .unsignedToTempString!16 == "12abcf");    assert(long.sizeof.unsignedToTempString == "8");    assert(uint.max.unsignedToTempString == "4294967295");    assert(ulong.max.unsignedToTempString == "18446744073709551615");     // test bad radices    assert(!is(typeof(100.unsignedToTempString!1(buf))));    assert(!is(typeof(100.unsignedToTempString!0(buf) == "")));    assert(!is(typeof(100.unsignedToTempString!37(buf) == "")));} alias SignedStringBuf = char[65]; T[] signedToTempString(uint radix = 10, bool upperCase = false, T)(long value, return scope T[] buf){    bool neg = value < 0;    if (neg)        value = cast(ulong)-value;    auto r = unsignedToTempString!(radix, upperCase)(value, buf);    if (neg)    {        // about to do a slice without a bounds check        auto trustedSlice(return scope T[] r) @trusted { assert(r.ptr > buf.ptr); return (r.ptr-1)[0..r.length+1]; }        r = trustedSlice(r);        r[0] = '-';    }    return r;} auto signedToTempString(uint radix = 10)(long value){    bool neg = value < 0;    if (neg)        value = cast(ulong)-value;    auto r = unsignedToTempString!radix(value);    if (neg)    {        r._len++;        r.get()[0] = '-';    }    return r;} unittest{    SignedStringBuf buf = void;    assert(0.signedToTempString(buf) == "0");    assert(1.signedToTempString(buf) == "1");    assert((-1).signedToTempString(buf) == "-1");    assert(12.signedToTempString(buf) == "12");    assert((-12).signedToTempString(buf) == "-12");    assert(0x12ABCF .signedToTempString!16(buf) == "12abcf");    assert((-0x12ABCF) .signedToTempString!16(buf) == "-12abcf");    assert((-0x12ABCF) .signedToTempString!(16, true)(buf) == "-12ABCF");    assert(long.sizeof.signedToTempString(buf) == "8");    assert(int.max.signedToTempString(buf) == "2147483647");    assert(int.min.signedToTempString(buf) == "-2147483648");    assert(long.max.signedToTempString(buf) == "9223372036854775807");    assert(long.min.signedToTempString(buf) == "-9223372036854775808");     wchar[65] wbuf = void;    assert(1.signedToTempString(wbuf) == "1"w);     dchar[65] dbuf = void;    assert(1.signedToTempString(dbuf) == "1"d);     // use stack allocated struct version    assert(0.signedToTempString() == "0");    assert(1.signedToTempString == "1");    assert((-1).signedToTempString == "-1");    assert(12.signedToTempString == "12");    assert((-12).signedToTempString == "-12");    assert(0x12ABCF .signedToTempString!16 == "12abcf");    assert((-0x12ABCF) .signedToTempString!16 == "-12abcf");    assert(long.sizeof.signedToTempString == "8");    assert(int.max.signedToTempString == "2147483647");    assert(int.min.signedToTempString == "-2147483648");    assert(long.max.signedToTempString == "9223372036854775807");    assert(long.min.signedToTempString == "-9223372036854775808");    assert(long.max.signedToTempString!2 == "111111111111111111111111111111111111111111111111111111111111111");    assert(long.min.signedToTempString!2 == "-1000000000000000000000000000000000000000000000000000000000000000");}  /******************************** * Determine number of digits that will result from a * conversion of value to a string. * Params: *      value = number to convert *      radix = radix * Returns: *      number of digits */int numDigits(uint radix = 10)(ulong value) if (radix >= 2 && radix <= 36){     int n = 1;     while (1)     {        if (value <= uint.max)        {            uint v = cast(uint)value;            while (1)            {                if (v < radix)                    return n;                if (v < radix * radix)                    return n + 1;                if (v < radix * radix * radix)                    return n + 2;                if (v < radix * radix * radix * radix)                    return n + 3;                n += 4;                v /= radix * radix * radix * radix;            }        }        n += 4;        value /= radix * radix * radix * radix;     }} unittest{    assert(0.numDigits == 1);    assert(9.numDigits == 1);    assert(10.numDigits == 2);    assert(99.numDigits == 2);    assert(100.numDigits == 3);    assert(999.numDigits == 3);    assert(1000.numDigits == 4);    assert(9999.numDigits == 4);    assert(10000.numDigits == 5);    assert(99999.numDigits == 5);    assert(uint.max.numDigits == 10);    assert(ulong.max.numDigits == 20);     assert(0.numDigits!2 == 1);    assert(1.numDigits!2 == 1);    assert(2.numDigits!2 == 2);    assert(3.numDigits!2 == 2);     // test bad radices    static assert(!__traits(compiles, 100.numDigits!1()));    static assert(!__traits(compiles, 100.numDigits!0()));    static assert(!__traits(compiles, 100.numDigits!37()));} int dstrcmp()( scope const char[] s1, scope const char[] s2 ) @trusted{    immutable len = s1.length <= s2.length ? s1.length : s2.length;    if (__ctfe)    {        foreach (const u; 0 .. len)        {            if (s1[u] != s2[u])                return s1[u] > s2[u] ? 1 : -1;        }    }    else    {        import core.stdc.string : memcmp;         const ret = memcmp( s1.ptr, s2.ptr, len );        if ( ret )            return ret;    }    return (s1.length > s2.length) - (s1.length < s2.length);}