libphobos/libdruntime/core/internal/string.d

   1 /**
   2  * String manipulation and comparison utilities.
   3  *
   4  * Copyright: Copyright Sean Kelly 2005 - 2009.
   5  * License:   $(WEB www.boost.org/LICENSE_1_0.txt, Boost License 1.0).
   6  * Authors:   Sean Kelly, Walter Bright
   7  * Source: $(DRUNTIMESRC src/rt/util/_string.d)
   8  */
   9
  10 module core.internal.string;
  11
  12 pure:
  13 nothrow:
  14 @nogc:
  15
  16 alias UnsignedStringBuf = char[20];
  17
  18 char[] unsignedToTempString(ulong value, return char[] buf, uint radix = 10) @safe
  19 {
  20     size_t i = buf.length;
  21     do
  22     {
  23         ubyte x = cast(ubyte)(value % radix);
  24         value = value / radix;
  25         buf[--i] = cast(char)((x < 10) ? x + '0' : x - 10 + 'a');
  26     } while (value);
  27     return buf[i .. $];
  28 }
  29
  30 private struct TempStringNoAlloc
  31 {
  32     // need to handle 65 bytes for radix of 2 with negative sign.
  33     private char[65] _buf;
  34     private ubyte _len;
  35     auto get() return
  36     {
  37         return _buf[$-_len..$];
  38     }
  39     alias get this;
  40 }
  41
  42 auto unsignedToTempString(ulong value, uint radix) @safe
  43 {
  44     TempStringNoAlloc result = void;
  45     result._len = unsignedToTempString(value, result._buf, radix).length & 0xff;
  46     return result;
  47 }
  48
  49 unittest
  50 {
  51     UnsignedStringBuf buf;
  52     assert(0.unsignedToTempString(buf, 10) == "0");
  53     assert(1.unsignedToTempString(buf, 10) == "1");
  54     assert(12.unsignedToTempString(buf, 10) == "12");
  55     assert(0x12ABCF .unsignedToTempString(buf, 16) == "12abcf");
  56     assert(long.sizeof.unsignedToTempString(buf, 10) == "8");
  57     assert(uint.max.unsignedToTempString(buf, 10) == "4294967295");
  58     assert(ulong.max.unsignedToTempString(buf, 10) == "18446744073709551615");
  59
  60     // use stack allocated struct version
  61     assert(0.unsignedToTempString(10) == "0");
  62     assert(1.unsignedToTempString(10) == "1");
  63     assert(12.unsignedToTempString(10) == "12");
  64     assert(0x12ABCF .unsignedToTempString(16) == "12abcf");
  65     assert(long.sizeof.unsignedToTempString(10) == "8");
  66     assert(uint.max.unsignedToTempString(10) == "4294967295");
  67     assert(ulong.max.unsignedToTempString(10) == "18446744073709551615");
  68 }
  69
  70 alias SignedStringBuf = char[20];
  71
  72 char[] signedToTempString(long value, return char[] buf, uint radix) @safe
  73 {
  74     bool neg = value < 0;
  75     if (neg)
  76         value = cast(ulong)-value;
  77     auto r = unsignedToTempString(value, buf, radix);
  78     if (neg)
  79     {
  80         // about to do a slice without a bounds check
  81         auto trustedSlice(return char[] r) @trusted { assert(r.ptr > buf.ptr); return (r.ptr-1)[0..r.length+1]; }
  82         r = trustedSlice(r);
  83         r[0] = '-';
  84     }
  85     return r;
  86 }
  87
  88 auto signedToTempString(long value, uint radix) @safe
  89 {
  90     bool neg = value < 0;
  91     if (neg)
  92         value = cast(ulong)-value;
  93     auto r = unsignedToTempString(value, radix);
  94     if (neg)
  95     {
  96         r._len++;
  97         r.get()[0] = '-';
  98     }
  99     return r;
 100 }
 101
 102 unittest
 103 {
 104     SignedStringBuf buf;
 105     assert(0.signedToTempString(buf, 10) == "0");
 106     assert(1.signedToTempString(buf, 10) == "1");
 107     assert((-1).signedToTempString(buf, 10) == "-1");
 108     assert(12.signedToTempString(buf, 10) == "12");
 109     assert((-12).signedToTempString(buf, 10) == "-12");
 110     assert(0x12ABCF .signedToTempString(buf, 16) == "12abcf");
 111     assert((-0x12ABCF) .signedToTempString(buf, 16) == "-12abcf");
 112     assert(long.sizeof.signedToTempString(buf, 10) == "8");
 113     assert(int.max.signedToTempString(buf, 10) == "2147483647");
 114     assert(int.min.signedToTempString(buf, 10) == "-2147483648");
 115     assert(long.max.signedToTempString(buf, 10) == "9223372036854775807");
 116     assert(long.min.signedToTempString(buf, 10) == "-9223372036854775808");
 117
 118     // use stack allocated struct version
 119     assert(0.signedToTempString(10) == "0");
 120     assert(1.signedToTempString(10) == "1");
 121     assert((-1).signedToTempString(10) == "-1");
 122     assert(12.signedToTempString(10) == "12");
 123     assert((-12).signedToTempString(10) == "-12");
 124     assert(0x12ABCF .signedToTempString(16) == "12abcf");
 125     assert((-0x12ABCF) .signedToTempString(16) == "-12abcf");
 126     assert(long.sizeof.signedToTempString(10) == "8");
 127     assert(int.max.signedToTempString(10) == "2147483647");
 128     assert(int.min.signedToTempString(10) == "-2147483648");
 129     assert(long.max.signedToTempString(10) == "9223372036854775807");
 130     assert(long.min.signedToTempString(10) == "-9223372036854775808");
 131     assert(long.max.signedToTempString(2) == "111111111111111111111111111111111111111111111111111111111111111");
 132     assert(long.min.signedToTempString(2) == "-1000000000000000000000000000000000000000000000000000000000000000");
 133 }
 134
 135
 136 /********************************
 137  * Determine number of digits that will result from a
 138  * conversion of value to a string.
 139  * Params:
 140  *      value = number to convert
 141  *      radix = radix
 142  * Returns:
 143  *      number of digits
 144  */
 145 int numDigits(uint radix = 10)(ulong value) @safe
 146 {
 147      int n = 1;
 148      while (1)
 149      {
 150         if (value <= uint.max)
 151         {
 152             uint v = cast(uint)value;
 153             while (1)
 154             {
 155                 if (v < radix)
 156                     return n;
 157                 if (v < radix * radix)
 158                     return n + 1;
 159                 if (v < radix * radix * radix)
 160                     return n + 2;
 161                 if (v < radix * radix * radix * radix)
 162                     return n + 3;
 163                 n += 4;
 164                 v /= radix * radix * radix * radix;
 165             }
 166         }
 167         n += 4;
 168         value /= radix * radix * radix * radix;
 169      }
 170 }
 171
 172 unittest
 173 {
 174     assert(0.numDigits == 1);
 175     assert(9.numDigits == 1);
 176     assert(10.numDigits == 2);
 177     assert(99.numDigits == 2);
 178     assert(100.numDigits == 3);
 179     assert(999.numDigits == 3);
 180     assert(1000.numDigits == 4);
 181     assert(9999.numDigits == 4);
 182     assert(10000.numDigits == 5);
 183     assert(99999.numDigits == 5);
 184     assert(uint.max.numDigits == 10);
 185     assert(ulong.max.numDigits == 20);
 186
 187     assert(0.numDigits!2 == 1);
 188     assert(1.numDigits!2 == 1);
 189     assert(2.numDigits!2 == 2);
 190     assert(3.numDigits!2 == 2);
 191 }
 192
 193 int dstrcmp( scope const char[] s1, scope const char[] s2 ) @trusted
 194 {
 195     immutable len = s1.length <= s2.length ? s1.length : s2.length;
 196     if (__ctfe)
 197     {
 198         foreach (const u; 0 .. len)
 199         {
 200             if (s1[u] != s2[u])
 201                 return s1[u] > s2[u] ? 1 : -1;
 202         }
 203     }
 204     else
 205     {
 206         import core.stdc.string : memcmp;
 207
 208         const ret = memcmp( s1.ptr, s2.ptr, len );
 209         if ( ret )
 210             return ret;
 211     }
 212     return s1.length < s2.length ? -1 : (s1.length > s2.length);
 213 }