Add in support for hex literals using underscores (#354)

rv32ima · web-flow · commit 0f8e5144531d · 2021-08-16T21:45:09.000+07:00
* Add in support for hex literals using underscores

* check for invalid underscores

* add more test cases, unify into one test
diff --git a/source/mir/bignum/fixed.d b/source/mir/bignum/fixed.d
@@ -197,10 +197,10 @@ struct UInt(size_t size)
     }
 
     ///
-    static UInt!size fromHexString(scope const(char)[] str)
+    static UInt!size fromHexString(bool allowUnderscores = false)(scope const(char)[] str)
     {
         typeof(return) ret;
-        if (ret.fromHexStringImpl(str))
+        if (ret.fromHexStringImpl!(char, allowUnderscores)(str))
             return ret;
         version(D_Exceptions)
         {
@@ -216,11 +216,11 @@ struct UInt(size_t size)
 
     /++
     +/
-    bool fromHexStringImpl(C)(scope const(C)[] str)
+    bool fromHexStringImpl(C, bool allowUnderscores = false)(scope const(C)[] str)
         @safe pure @nogc nothrow
         if (isSomeChar!C)
     {
-        return view.fromHexStringImpl(str);
+        return view.fromHexStringImpl!(C, allowUnderscores)(str);
     }
 
     /++
diff --git a/source/mir/bignum/integer.d b/source/mir/bignum/integer.d
@@ -366,11 +366,11 @@ struct BigInt(size_t maxSize64)
 
     /++
     +/
-    static BigInt fromHexString()(scope const(char)[] str)
+    static BigInt fromHexString(bool allowUnderscores = false)(scope const(char)[] str)
         @trusted pure
     {
         BigInt ret;
-        if (ret.fromHexStringImpl(str))
+        if (ret.fromHexStringImpl!(char, allowUnderscores)(str))
             return ret;
         version(D_Exceptions)
             throw hexStringException;
@@ -380,12 +380,12 @@ struct BigInt(size_t maxSize64)
 
     /++
     +/
-    bool fromHexStringImpl(C)(scope const(C)[] str)
+    bool fromHexStringImpl(C, bool allowUnderscores = false)(scope const(C)[] str)
         @safe pure @nogc nothrow
         if (isSomeChar!C)
     {
         auto work = BigIntView!size_t(data);
-        auto ret = work.fromHexStringImpl(str);
+        auto ret = work.fromHexStringImpl!(C, allowUnderscores)(str);
         if (ret)
         {
             length = cast(uint)work.unsigned.coefficients.length;
diff --git a/source/mir/bignum/low_level_view.d b/source/mir/bignum/low_level_view.d
@@ -565,14 +565,15 @@ struct BigUIntView(W, WordEndian endian = TargetEndian)
 
     /++
     +/
-    static BigUIntView fromHexString(C)(scope const(C)[] str)
+    static BigUIntView fromHexString(C, bool allowUnderscores = false)(scope const(C)[] str)
         @trusted pure
         if (isSomeChar!C)
     {
         auto length = str.length / (W.sizeof * 2) + (str.length % (W.sizeof * 2) != 0);
         auto data = new Unqual!W[length];
-        if (BigUIntView!(Unqual!W, endian)(data).fromHexStringImpl(str))
-            return BigUIntView(cast(W[])data);
+        auto view = BigUIntView!(Unqual!W, endian)(data);
+        if (view.fromHexStringImpl!(C, allowUnderscores)(str))
+            return BigUIntView(cast(W[])view.coefficients);
         version(D_Exceptions)
             throw hexStringException;
         else
@@ -582,18 +583,26 @@ struct BigUIntView(W, WordEndian endian = TargetEndian)
     static if (isMutable!W)
     /++
     +/
-    bool fromHexStringImpl(C)(scope const(C)[] str)
+    bool fromHexStringImpl(C, bool allowUnderscores = false)(scope const(C)[] str)
         @safe pure @nogc nothrow scope
         if (isSomeChar!C)
     {
         pragma(inline, false);
         import mir.utility: _expect;
-        if (_expect(str.length == 0 || str.length > coefficients.length * W.sizeof * 2, false))
-            return false;
-        coefficients = coefficients[0 .. str.length / (W.sizeof * 2) + (str.length % (W.sizeof * 2) != 0)];
-        auto rdata = leastSignificantFirst;
+        static if (allowUnderscores) {
+            if (_expect(str.length == 0, false)) // can't tell how big the coeff array needs to be, rely on a runtime check
+                return false;
+        } else {
+            if (_expect(str.length == 0 || str.length > coefficients.length * W.sizeof * 2, false))
+                return false;
+        }
+
+        leastSignificant = 0;
+        auto work = topLeastSignificantPart(1);
         W current;
-        size_t i;
+        size_t i, j;
+        static if (allowUnderscores) bool recentUnderscore;
+
         do
         {
             ubyte c;
@@ -621,28 +630,98 @@ struct BigUIntView(W, WordEndian endian = TargetEndian)
                 case 'e': c = 0xE; break;
                 case 'F':
                 case 'f': c = 0xF; break;
+                static if (allowUnderscores) 
+                {
+                    case '_': 
+                        if (recentUnderscore) return false;
+                        recentUnderscore = true;
+                        continue;
+                }
                 default: return false;
             }
+            ++j;
+            static if (allowUnderscores) recentUnderscore = false;
+            // how far do we need to shift to get to the top 4 bits
             enum s = W.sizeof * 8 - 4;
+            // shift number to the top most 4 bits
             W cc = cast(W)(W(c) << s);
+            // shift unsigned right 4 bits
             current >>>= 4;
+            // add number to top most 4 bits of current var
             current |= cc;
-            if (i % (W.sizeof * 2) == 0)
+            if (j % (W.sizeof * 2) == 0) // is this packed var full? 
             {
-                rdata.front = current;
-                rdata.popFront;
+                work.mostSignificant = current;
                 current = 0;
+                if (_expect(work.coefficients.length < coefficients.length, true))
+                {
+                    work = topLeastSignificantPart(work.coefficients.length + 1);
+                }
+                else if (i < str.length) // if we've run out of coefficients before reaching the end of the string, error
+                {
+                    return false;
+                }
             }
         }
         while(i < str.length);
+
+        static if (allowUnderscores) 
+        {
+            // check for a underscore at the beginning or the end
+            if (recentUnderscore || str[$ - 1] == '_') return false;
+        }
+
         if (current)
         {
-            current >>>= 4 * (W.sizeof * 2 - i % (W.sizeof * 2));
-            rdata.front = current;
+            current >>>= 4 * (W.sizeof * 2 - j % (W.sizeof * 2));
+            work.mostSignificant = current;
         }
+
+        coefficients = coefficients[0 .. (j / (W.sizeof * 2) + (j % (W.sizeof * 2) != 0))];
+
         return true;
     }
 
+    static if (W.sizeof == size_t.sizeof && endian == TargetEndian)
+    ///
+    version(mir_bignum_test)
+    @safe pure
+    unittest
+    {
+        auto view = BigUIntView!size_t.fromHexString!(char, true)("abcd_efab_cdef");
+        assert(cast(ulong)view == 0xabcd_efab_cdef);
+    }
+
+    static if (W.sizeof == size_t.sizeof && endian == TargetEndian)
+    ///
+    version(mir_bignum_test)
+    @safe pure
+    unittest
+    {
+        // Check that invalid underscores in hex literals throw an error.
+        void expectThrow(const(char)[] input) {
+            bool caught = false;
+            try { 
+                auto view = BigUIntView!size_t.fromHexString!(char, true)(input);
+            } catch (Exception e) {
+                caught = true;
+            }
+
+            assert(caught);
+        }
+
+        expectThrow("abcd_efab_cef_");
+        expectThrow("abcd__efab__cef");
+        expectThrow("_abcd_efab_cdef");
+        expectThrow("_abcd_efab_cdef_");
+        expectThrow("_abcd_efab_cdef__");
+        expectThrow("__abcd_efab_cdef");
+        expectThrow("__abcd_efab_cdef_");
+        expectThrow("__abcd_efab_cdef__");
+        expectThrow("__abcd__efab_cdef__");
+        expectThrow("__abcd__efab__cdef__");
+    }
+
     static if (isMutable!W && W.sizeof >= 4)
     /++
     Returns: false in case of overflow or incorrect string.
@@ -1378,13 +1457,13 @@ struct BigIntView(W, WordEndian endian = TargetEndian)
 
     /++
     +/
-    static BigIntView fromHexString(C)(scope const(C)[] str)
+    static BigIntView fromHexString(C, bool allowUnderscores = false)(scope const(C)[] str)
         @trusted pure
         if (isSomeChar!C)
     {
         auto length = str.length / (W.sizeof * 2) + (str.length % (W.sizeof * 2) != 0);
         auto ret = BigIntView!(Unqual!W, endian)(new Unqual!W[length]);
-        if (ret.fromHexStringImpl(str))
+        if (ret.fromHexStringImpl!(C, allowUnderscores)(str))
             return  cast(BigIntView) ret;
         version(D_Exceptions)
             throw hexStringException;
@@ -1395,7 +1474,7 @@ struct BigIntView(W, WordEndian endian = TargetEndian)
     static if (isMutable!W)
     /++
     +/
-    bool fromHexStringImpl(C)(scope const(C)[] str)
+    bool fromHexStringImpl(C, bool allowUnderscores = false)(scope const(C)[] str)
         @safe pure @nogc nothrow
         if (isSomeChar!C)
     {
@@ -1420,7 +1499,7 @@ struct BigIntView(W, WordEndian endian = TargetEndian)
             str = str[1 .. $];
         }
 
-        return unsigned.fromHexStringImpl(str);
+        return unsigned.fromHexStringImpl!(C, allowUnderscores)(str);
     }
 
     ///
@@ -1443,6 +1522,15 @@ struct BigIntView(W, WordEndian endian = TargetEndian)
         assert(a == -0xa.fbbfae3cd0bp+124);
     }
 
+    static if (W.sizeof == size_t.sizeof && endian == TargetEndian)
+    ///
+    version(mir_bignum_test)
+    @safe pure
+    unittest
+    {
+        auto a = cast(double) BigIntView!size_t.fromHexString!(char, true)("-afbb_fae3_cd0a_ff27_14a1_de70_22b0_029d");
+        assert(a == -0xa.fbbfae3cd0bp+124);
+    }
 
     ///
     T opCast(T, bool nonZero = false)() scope const
@@ -1465,6 +1553,17 @@ struct BigIntView(W, WordEndian endian = TargetEndian)
         assert(cast(int) view == -0x22b0021d);
     }
 
+    static if (W.sizeof == size_t.sizeof && endian == TargetEndian)
+    ///
+    version(mir_bignum_test)
+    @safe pure
+    unittest
+    {
+        auto view = BigIntView!size_t.fromHexString!(char, true)("-afbb_fae3_cd0a_ff27_14a1_de70_22b0_021d");
+        assert(cast(long) view == -0x14a1de7022b0021d);
+        assert(cast(int) view == -0x22b0021d);
+    }
+
     static if (W.sizeof == size_t.sizeof && endian == TargetEndian)
     version(mir_bignum_test)
     @safe pure
@@ -1474,6 +1573,16 @@ struct BigIntView(W, WordEndian endian = TargetEndian)
         assert(cast(long) view == -0x14a1de7022b0021d);
         assert(cast(int) view == -0x22b0021d);
     }
+    
+    static if (W.sizeof == size_t.sizeof && endian == TargetEndian)
+    version(mir_bignum_test)
+    @safe pure
+    unittest
+    {
+        auto view = BigIntView!ushort.fromHexString!(char, true)("-afbb_fae3_cd0a_ff27_14a1_de70_22b0_021d");
+        assert(cast(long) view == -0x14a1de7022b0021d);
+        assert(cast(int) view == -0x22b0021d);
+    }
 
     static if (W.sizeof == size_t.sizeof && endian == TargetEndian)
     version(mir_bignum_test)
@@ -1485,6 +1594,16 @@ struct BigIntView(W, WordEndian endian = TargetEndian)
         assert(cast(int) view == -0x22b0021d);
     }
 
+    static if (W.sizeof == size_t.sizeof && endian == TargetEndian)
+    version(mir_bignum_test)
+    @safe pure
+    unittest
+    {
+        auto view = BigIntView!ubyte.fromHexString!(char, true)("-afbb_fae3_cd0a_ff27_14a1_de70_22b0_021d");
+        assert(cast(long) view == -0x14a1de7022b0021d);
+        assert(cast(int) view == -0x22b0021d);
+    }
+
     /++
     +/
     T opCast(T : Fp!coefficientSize, size_t internalRoundLastBits = 0, bool wordNormalized = false, bool nonZero = false, size_t coefficientSize)() scope const
@@ -1510,6 +1629,20 @@ struct BigIntView(W, WordEndian endian = TargetEndian)
         assert(fp.coefficient == UInt!128.fromHexString("afbbfae3cd0aff2714a1de7022b0029d"));
     }
 
+    static if (W.sizeof == size_t.sizeof && endian == TargetEndian)
+    version(mir_bignum_test)
+    @safe pure
+    unittest
+    {
+        import mir.bignum.fixed: UInt;
+        import mir.bignum.fp: Fp;
+
+        auto fp = cast(Fp!128) BigIntView!size_t.fromHexString!(char, true)("-afbb_fae3_cd0a_ff27_14a1_de70_22b0_029d");
+        assert(fp.sign);
+        assert(fp.exponent == 0);
+        assert(fp.coefficient == UInt!128.fromHexString("afbbfae3cd0aff2714a1de7022b0029d"));
+    }
+
     static if (endian == TargetEndian)
     ///
     BigIntView!V opCast(T : BigIntView!V, V)() scope return
@@ -1821,6 +1954,20 @@ unittest
 
 }
 
+///
+version(mir_bignum_test)
+unittest
+{
+    import mir.bignum.fixed: UInt;
+    import mir.bignum.low_level_view: BigUIntView;
+    auto bigView2 = BigUIntView!size_t.fromHexString("55a325ad18b2a77120d870d987d5237473790532acab45da44bc07c92c92babf0b5e2e2c7771cd472ae5d7acdb159a56fbf74f851a058ae341f69d1eb750d7e3");
+    auto bigView = BigUIntView!size_t.fromHexString!(char, true)("55a3_25ad_18b2_a771_20d8_70d9_87d5_2374_7379_0532_acab_45da_44bc_07c9_2c92_babf_0b5e_2e2c_7771_cd47_2ae5_d7ac_db15_9a56_fbf7_4f85_1a05_8ae3_41f6_9d1e_b750_d7e3");
+    auto fixed = UInt!256.fromHexString!(true)("55e5_6695_76d3_1726_f4a9_b58a_9015_9de5_923a_dc6c_762e_bd3c_4ba5_18d4_9522_9072");
+    auto overflow = bigView *= fixed;
+    assert(overflow == UInt!256.fromHexString("1cbbe8c42dc21f936e4ce5b2f52ac404439857f174084012fcd1b71fdec2a398"));
+    assert(bigView == BigUIntView!size_t.fromHexString("c73fd2b26f2514c103c324943b6c90a05d2732118d5f0099c36a69a8051bb0573adc825b5c9295896c70280faa4c4d369df8e92f82bfffafe078b52ae695d316"));
+}
+
 /++
 An utility type to wrap a local buffer to accumulate unsigned numbers.
 +/

Original file line number	Diff line number	Diff line change
`@@ -197,10 +197,10 @@ struct UInt(size_t size)`
`197`	`197`	`}`
`198`	`198`
`199`	`199`	`///`
`200`		`- static UInt!size fromHexString(scope const(char)[] str)`
	`200`	`+ static UInt!size fromHexString(bool allowUnderscores = false)(scope const(char)[] str)`
`201`	`201`	`{`
`202`	`202`	`typeof(return) ret;`
`203`		`- if (ret.fromHexStringImpl(str))`
	`203`	`+ if (ret.fromHexStringImpl!(char, allowUnderscores)(str))`
`204`	`204`	`return ret;`
`205`	`205`	`version(D_Exceptions)`
`206`	`206`	`{`
`@@ -216,11 +216,11 @@ struct UInt(size_t size)`
`216`	`216`
`217`	`217`	`/++`
`218`	`218`	`+/`
`219`		`- bool fromHexStringImpl(C)(scope const(C)[] str)`
	`219`	`+ bool fromHexStringImpl(C, bool allowUnderscores = false)(scope const(C)[] str)`
`220`	`220`	`@safe pure @nogc nothrow`
`221`	`221`	`if (isSomeChar!C)`
`222`	`222`	`{`
`223`		`- return view.fromHexStringImpl(str);`
	`223`	`+ return view.fromHexStringImpl!(C, allowUnderscores)(str);`
`224`	`224`	`}`
`225`	`225`
`226`	`226`	`/++`