Skip to content
This repository was archived by the owner on Oct 12, 2022. It is now read-only.

Commit 4cfb704

Browse files
Geod24Geod24
authored
Revert "EASY: Move radix to template parameter in unsignedToTempString"
1 parent 7706437 commit 4cfb704

File tree

6 files changed

+60
-57
lines changed

6 files changed

+60
-57
lines changed

‎src/core/demangle.d

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -279,7 +279,7 @@ pure @safe:
279279

280280
UnsignedStringBuf buf = void;
281281

282-
auto s = unsignedToTempString!16(val, buf);
282+
auto s = unsignedToTempString(val, buf, 16);
283283
int slen = cast(int)s.length;
284284
if (slen < width)
285285
{

‎src/core/internal/abort.d

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -48,6 +48,6 @@ void abort(scope string msg, scope string filename = __FILE__, size_t line = __L
4848
UnsignedStringBuf strbuff = void;
4949

5050
// write an appropriate message, then abort the program
51-
writeStr("Aborting from ", filename, "(", line.unsignedToTempString(strbuff), ") ", msg);
51+
writeStr("Aborting from ", filename, "(", line.unsignedToTempString(strbuff, 10), ") ", msg);
5252
c_abort();
5353
}

‎src/core/internal/string.d

Lines changed: 36 additions & 33 deletions
Original file line numberDiff line numberDiff line change
@@ -28,24 +28,27 @@ Params:
2828
Returns:
2929
The unsigned integer value as a string of characters
3030
*/
31-
char[] unsignedToTempString(uint radix = 10)(ulong value, return scope char[] buf) @safe
32-
if (radix >= 2 && radix <= 16)
31+
char[] unsignedToTempString()(ulong value, return scope char[] buf, uint radix = 10) @safe
3332
{
33+
if (radix < 2)
34+
// not a valid radix, just return an empty string
35+
return buf[$ .. $];
36+
3437
size_t i = buf.length;
3538
do
3639
{
37-
uint x = void;
3840
if (value < radix)
3941
{
40-
x = cast(uint)value;
41-
value = 0;
42+
ubyte x = cast(ubyte)value;
43+
buf[--i] = cast(char)((x < 10) ? x + '0' : x - 10 + 'a');
44+
break;
4245
}
4346
else
4447
{
45-
x = cast(uint)(value % radix);
46-
value /= radix;
48+
ubyte x = cast(ubyte)(value % radix);
49+
value = value / radix;
50+
buf[--i] = cast(char)((x < 10) ? x + '0' : x - 10 + 'a');
4751
}
48-
buf[--i] = cast(char)((radix <= 10 || x < 10) ? x + '0' : x - 10 + 'a');
4952
} while (value);
5053
return buf[i .. $];
5154
}
@@ -74,46 +77,46 @@ Params:
7477
Returns:
7578
The unsigned integer value as a string of characters
7679
*/
77-
auto unsignedToTempString(uint radix = 10)(ulong value) @safe
80+
auto unsignedToTempString()(ulong value, uint radix = 10) @safe
7881
{
7982
TempStringNoAlloc!() result = void;
80-
result._len = unsignedToTempString!radix(value, result._buf).length & 0xff;
83+
result._len = unsignedToTempString(value, result._buf, radix).length & 0xff;
8184
return result;
8285
}
8386

8487
unittest
8588
{
8689
UnsignedStringBuf buf;
87-
assert(0.unsignedToTempString(buf) == "0");
88-
assert(1.unsignedToTempString(buf) == "1");
89-
assert(12.unsignedToTempString(buf) == "12");
90-
assert(0x12ABCF .unsignedToTempString!16(buf) == "12abcf");
91-
assert(long.sizeof.unsignedToTempString(buf) == "8");
92-
assert(uint.max.unsignedToTempString(buf) == "4294967295");
93-
assert(ulong.max.unsignedToTempString(buf) == "18446744073709551615");
90+
assert(0.unsignedToTempString(buf, 10) == "0");
91+
assert(1.unsignedToTempString(buf, 10) == "1");
92+
assert(12.unsignedToTempString(buf, 10) == "12");
93+
assert(0x12ABCF .unsignedToTempString(buf, 16) == "12abcf");
94+
assert(long.sizeof.unsignedToTempString(buf, 10) == "8");
95+
assert(uint.max.unsignedToTempString(buf, 10) == "4294967295");
96+
assert(ulong.max.unsignedToTempString(buf, 10) == "18446744073709551615");
9497

9598
// use stack allocated struct version
96-
assert(0.unsignedToTempString == "0");
99+
assert(0.unsignedToTempString(10) == "0");
97100
assert(1.unsignedToTempString == "1");
98101
assert(12.unsignedToTempString == "12");
99-
assert(0x12ABCF .unsignedToTempString!16 == "12abcf");
102+
assert(0x12ABCF .unsignedToTempString(16) == "12abcf");
100103
assert(long.sizeof.unsignedToTempString == "8");
101104
assert(uint.max.unsignedToTempString == "4294967295");
102105
assert(ulong.max.unsignedToTempString == "18446744073709551615");
103106

104107
// test bad radices
105-
assert(!is(typeof(100.unsignedToTempString!1(buf))));
106-
assert(!is(typeof(100.unsignedToTempString!0(buf) == "")));
108+
assert(100.unsignedToTempString(buf, 1) == "");
109+
assert(100.unsignedToTempString(buf, 0) == "");
107110
}
108111

109112
alias SignedStringBuf = char[20];
110113

111-
char[] signedToTempString(uint radix = 10)(long value, return scope char[] buf) @safe
114+
char[] signedToTempString(long value, return scope char[] buf, uint radix = 10) @safe
112115
{
113116
bool neg = value < 0;
114117
if (neg)
115118
value = cast(ulong)-value;
116-
auto r = unsignedToTempString!radix(value, buf);
119+
auto r = unsignedToTempString(value, buf, radix);
117120
if (neg)
118121
{
119122
// about to do a slice without a bounds check
@@ -124,12 +127,12 @@ char[] signedToTempString(uint radix = 10)(long value, return scope char[] buf)
124127
return r;
125128
}
126129

127-
auto signedToTempString(uint radix = 10)(long value) @safe
130+
auto signedToTempString(long value, uint radix = 10) @safe
128131
{
129132
bool neg = value < 0;
130133
if (neg)
131134
value = cast(ulong)-value;
132-
auto r = unsignedToTempString!radix(value);
135+
auto r = unsignedToTempString(value, radix);
133136
if (neg)
134137
{
135138
r._len++;
@@ -141,34 +144,34 @@ auto signedToTempString(uint radix = 10)(long value) @safe
141144
unittest
142145
{
143146
SignedStringBuf buf;
144-
assert(0.signedToTempString(buf) == "0");
147+
assert(0.signedToTempString(buf, 10) == "0");
145148
assert(1.signedToTempString(buf) == "1");
146149
assert((-1).signedToTempString(buf) == "-1");
147150
assert(12.signedToTempString(buf) == "12");
148151
assert((-12).signedToTempString(buf) == "-12");
149-
assert(0x12ABCF .signedToTempString(buf) == "12abcf");
150-
assert((-0x12ABCF) .signedToTempString(buf) == "-12abcf");
152+
assert(0x12ABCF .signedToTempString(buf, 16) == "12abcf");
153+
assert((-0x12ABCF) .signedToTempString(buf, 16) == "-12abcf");
151154
assert(long.sizeof.signedToTempString(buf) == "8");
152155
assert(int.max.signedToTempString(buf) == "2147483647");
153156
assert(int.min.signedToTempString(buf) == "-2147483648");
154157
assert(long.max.signedToTempString(buf) == "9223372036854775807");
155158
assert(long.min.signedToTempString(buf) == "-9223372036854775808");
156159

157160
// use stack allocated struct version
158-
assert(0.signedToTempString() == "0");
161+
assert(0.signedToTempString(10) == "0");
159162
assert(1.signedToTempString == "1");
160163
assert((-1).signedToTempString == "-1");
161164
assert(12.signedToTempString == "12");
162165
assert((-12).signedToTempString == "-12");
163-
assert(0x12ABCF .signedToTempString!16 == "12abcf");
164-
assert((-0x12ABCF) .signedToTempString!16 == "-12abcf");
166+
assert(0x12ABCF .signedToTempString(16) == "12abcf");
167+
assert((-0x12ABCF) .signedToTempString(16) == "-12abcf");
165168
assert(long.sizeof.signedToTempString == "8");
166169
assert(int.max.signedToTempString == "2147483647");
167170
assert(int.min.signedToTempString == "-2147483648");
168171
assert(long.max.signedToTempString == "9223372036854775807");
169172
assert(long.min.signedToTempString == "-9223372036854775808");
170-
assert(long.max.signedToTempString!2 == "111111111111111111111111111111111111111111111111111111111111111");
171-
assert(long.min.signedToTempString!2 == "-1000000000000000000000000000000000000000000000000000000000000000");
173+
assert(long.max.signedToTempString(2) == "111111111111111111111111111111111111111111111111111111111111111");
174+
assert(long.min.signedToTempString(2) == "-1000000000000000000000000000000000000000000000000000000000000000");
172175
}
173176

174177

‎src/core/internal/util/array.d

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -41,9 +41,9 @@ private void _enforceSameLength(const char[] action,
4141
string msg = "Array lengths don't match for ";
4242
msg ~= action;
4343
msg ~= ": ";
44-
msg ~= length1.unsignedToTempString(tmpBuff);
44+
msg ~= length1.unsignedToTempString(tmpBuff, 10);
4545
msg ~= " != ";
46-
msg ~= length2.unsignedToTempString(tmpBuff);
46+
msg ~= length2.unsignedToTempString(tmpBuff, 10);
4747
assert(0, msg);
4848
}
4949

@@ -59,9 +59,9 @@ private void _enforceNoOverlap(const char[] action,
5959
string msg = "Overlapping arrays in ";
6060
msg ~= action;
6161
msg ~= ": ";
62-
msg ~= overlappedBytes.unsignedToTempString(tmpBuff);
62+
msg ~= overlappedBytes.unsignedToTempString(tmpBuff, 10);
6363
msg ~= " byte(s) overlap of ";
64-
msg ~= bytes.unsignedToTempString(tmpBuff);
64+
msg ~= bytes.unsignedToTempString(tmpBuff, 10);
6565
assert(0, msg);
6666
}
6767

‎src/core/time.d

Lines changed: 16 additions & 16 deletions
Original file line numberDiff line numberDiff line change
@@ -1584,7 +1584,7 @@ public:
15841584
unit = "μs";
15851585
else
15861586
unit = plural ? units : units[0 .. $-1];
1587-
res ~= signedToTempString(val);
1587+
res ~= signedToTempString(val, 10);
15881588
res ~= " ";
15891589
res ~= unit;
15901590
}
@@ -1806,9 +1806,9 @@ unittest
18061806
auto _str(F)(F val)
18071807
{
18081808
static if (is(F == int) || is(F == long))
1809-
return signedToTempString(val);
1809+
return signedToTempString(val, 10);
18101810
else
1811-
return unsignedToTempString(val);
1811+
return unsignedToTempString(val, 10);
18121812
}
18131813

18141814
foreach (F; AliasSeq!(int,uint,long,ulong,float,double,real))
@@ -2405,10 +2405,10 @@ assert(before + timeElapsed == after);
24052405
string toString() const pure nothrow
24062406
{
24072407
static if (clockType == ClockType.normal)
2408-
return "MonoTime(" ~ signedToTempString(_ticks) ~ " ticks, " ~ signedToTempString(ticksPerSecond) ~ " ticks per second)";
2408+
return "MonoTime(" ~ signedToTempString(_ticks, 10) ~ " ticks, " ~ signedToTempString(ticksPerSecond, 10) ~ " ticks per second)";
24092409
else
2410-
return "MonoTimeImpl!(ClockType." ~ _clockName ~ ")(" ~ signedToTempString(_ticks) ~ " ticks, " ~
2411-
signedToTempString(ticksPerSecond) ~ " ticks per second)";
2410+
return "MonoTimeImpl!(ClockType." ~ _clockName ~ ")(" ~ signedToTempString(_ticks, 10) ~ " ticks, " ~
2411+
signedToTempString(ticksPerSecond, 10) ~ " ticks per second)";
24122412
}
24132413

24142414
version (CoreUnittest) unittest
@@ -2428,9 +2428,9 @@ assert(before + timeElapsed == after);
24282428
else
24292429
eat(str, "MonoTimeImpl!(ClockType."~_clockName~")(");
24302430

2431-
eat(str, signedToTempString(mt._ticks));
2431+
eat(str, signedToTempString(mt._ticks, 10));
24322432
eat(str, " ticks, ");
2433-
eat(str, signedToTempString(ticksPerSecond));
2433+
eat(str, signedToTempString(ticksPerSecond, 10));
24342434
eat(str, " ticks per second)");
24352435
}
24362436

@@ -3970,9 +3970,9 @@ string doubleToString(double value) @safe pure nothrow
39703970
if (value < 0 && cast(long)value == 0)
39713971
result = "-0";
39723972
else
3973-
result = signedToTempString(cast(long)value).idup;
3973+
result = signedToTempString(cast(long)value, 10).idup;
39743974
result ~= '.';
3975-
result ~= unsignedToTempString(cast(ulong)(_abs((value - cast(long)value) * 1_000_000) + .5));
3975+
result ~= unsignedToTempString(cast(ulong)(_abs((value - cast(long)value) * 1_000_000) + .5), 10);
39763976

39773977
while (result[$-1] == '0')
39783978
result = result[0 .. $-1];
@@ -3996,7 +3996,7 @@ unittest
39963996

39973997
version (CoreUnittest) const(char)* numToStringz()(long value) @trusted pure nothrow
39983998
{
3999-
return (signedToTempString(value) ~ "\0").ptr;
3999+
return (signedToTempString(value, 10) ~ "\0").ptr;
40004000
}
40014001

40024002

@@ -4121,9 +4121,9 @@ version (CoreUnittest) void assertApprox(D, E)(D actual,
41214121
{
41224122
if (actual.length < lower.length || actual.length > upper.length)
41234123
{
4124-
throw new AssertError(msg ~ (": [" ~ signedToTempString(lower.length) ~ "] [" ~
4125-
signedToTempString(actual.length) ~ "] [" ~
4126-
signedToTempString(upper.length) ~ "]").idup,
4124+
throw new AssertError(msg ~ (": [" ~ signedToTempString(lower.length, 10) ~ "] [" ~
4125+
signedToTempString(actual.length, 10) ~ "] [" ~
4126+
signedToTempString(upper.length, 10) ~ "]").idup,
41274127
__FILE__, line);
41284128
}
41294129
}
@@ -4145,7 +4145,7 @@ version (CoreUnittest) void assertApprox()(long actual,
41454145
size_t line = __LINE__)
41464146
{
41474147
if (actual < lower)
4148-
throw new AssertError(msg ~ ": lower: " ~ signedToTempString(actual).idup, __FILE__, line);
4148+
throw new AssertError(msg ~ ": lower: " ~ signedToTempString(actual, 10).idup, __FILE__, line);
41494149
if (actual > upper)
4150-
throw new AssertError(msg ~ ": upper: " ~ signedToTempString(actual).idup, __FILE__, line);
4150+
throw new AssertError(msg ~ ": upper: " ~ signedToTempString(actual, 10).idup, __FILE__, line);
41514151
}

‎src/object.d

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -628,7 +628,7 @@ class TypeInfo_StaticArray : TypeInfo
628628
import core.internal.string : unsignedToTempString;
629629

630630
char[20] tmpBuff = void;
631-
return value.toString() ~ "[" ~ unsignedToTempString(len, tmpBuff) ~ "]";
631+
return value.toString() ~ "[" ~ unsignedToTempString(len, tmpBuff, 10) ~ "]";
632632
}
633633

634634
override bool opEquals(Object o)
@@ -2006,7 +2006,7 @@ class Throwable : Object
20062006

20072007
sink(typeid(this).name);
20082008
sink("@"); sink(file);
2009-
sink("("); sink(unsignedToTempString(line, tmpBuff)); sink(")");
2009+
sink("("); sink(unsignedToTempString(line, tmpBuff, 10)); sink(")");
20102010

20112011
if (msg.length)
20122012
{

0 commit comments

Comments
 (0)