King_DuckZ/duckhandy
1
0
Fork 0
Code Issues Pull requests Releases Wiki Activity

Replace with consteval

Browse source 
It doesn't makes any sense to use this implementation
at runtime.
This commit is contained in:
King_DuckZ 2021-05-29 00:50:57 +02:00
parent 327d93a6a4
commit d068e68e75
2 changed files with 40 additions and 40 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

10
include/duckhandy/tiger_bt.hpp
View file

@ -24,18 +24,18 @@
namespace dhandy::bt { namespace dhandy::bt {
struct HashType { struct HashType {
constexpr HashType ( uint64_t parA, uint64_t parB, uint64_t parC ) : consteval HashType ( uint64_t parA, uint64_t parB, uint64_t parC ) :
a(parA), b(parB), c(parC) a(parA), b(parB), c(parC)
{ {
} }
constexpr HashType ( uint64_t parAP, uint64_t parA, uint64_t parBP, uint64_t parB, uint64_t parCP, uint64_t parC ) : consteval HashType ( uint64_t parAP, uint64_t parA, uint64_t parBP, uint64_t parB, uint64_t parCP, uint64_t parC ) :
a(0 == parAP ? parA : (0 == parBP ? parB : (0 == parCP ? parC : throw 0))), a(0 == parAP ? parA : (0 == parBP ? parB : (0 == parCP ? parC : throw 0))),
b(1 == parAP ? parA : (1 == parBP ? parB : (1 == parCP ? parC : throw 0))), b(1 == parAP ? parA : (1 == parBP ? parB : (1 == parCP ? parC : throw 0))),
c(2 == parAP ? parA : (2 == parBP ? parB : (2 == parCP ? parC : throw 0))) c(2 == parAP ? parA : (2 == parBP ? parB : (2 == parCP ? parC : throw 0)))
{ {
} }
constexpr HashType ( const HashType& ) = default; consteval HashType ( const HashType& ) = default;
constexpr uint64_t operator[] ( uint64_t parIndex ) const { consteval uint64_t operator[] ( uint64_t parIndex ) const {
return (parIndex == 0 ? a : return (parIndex == 0 ? a :
(parIndex == 1 ? b : (parIndex == 1 ? b :
(parIndex == 2 ? c : throw 0) (parIndex == 2 ? c : throw 0)
@ -52,7 +52,7 @@ namespace dhandy::bt {
inline const constexpr char TigerPaddingV2 = 0x80; inline const constexpr char TigerPaddingV2 = 0x80;
[[gnu::const]] [[gnu::const]]
constexpr HashType tiger ( const char* parStr, uint64_t parLen, char parPad ); consteval HashType tiger ( const char* parStr, uint64_t parLen, char parPad );
} //namespace dhandy::bt } //namespace dhandy::bt
#include "tiger_bt.inl" #include "tiger_bt.inl"

70
include/duckhandy/tiger_bt.inl
View file

@ -280,7 +280,7 @@ namespace dhandy::bt {
0xCB0C0708705A36A3ULL, 0xE74D14754F986044ULL, 0xCD56D9430EA8280EULL, 0xC12591D7535F5065ULL, 0xCB0C0708705A36A3ULL, 0xE74D14754F986044ULL, 0xCD56D9430EA8280EULL, 0xC12591D7535F5065ULL,
0xC83223F1720AEF96ULL, 0xC3A0396F7363A51FULL }; 0xC83223F1720AEF96ULL, 0xC3A0396F7363A51FULL };
constexpr uint64_t buff_to_uint64_with_filling (const char* parStr, const uint64_t parAvailLen) { consteval uint64_t buff_to_uint64_with_filling (const char* parStr, const uint64_t parAvailLen) {
return ( return (
parAvailLen == 0 ? parAvailLen == 0 ?
0 0
@ -291,7 +291,7 @@ namespace dhandy::bt {
); );
} }
constexpr uint64_t buff_to_uint64_fill_ifn (const char* parStr, uint64_t parIndex, uint64_t parBuffLen, char parPad) { consteval uint64_t buff_to_uint64_fill_ifn (const char* parStr, uint64_t parIndex, uint64_t parBuffLen, char parPad) {
return (sizeof(uint64_t) * parIndex >= parBuffLen ? return (sizeof(uint64_t) * parIndex >= parBuffLen ?
(sizeof(uint64_t) * parIndex == parBuffLen ? (sizeof(uint64_t) * parIndex == parBuffLen ?
static_cast<uint64_t>(static_cast<uint8_t>(parPad)) static_cast<uint64_t>(static_cast<uint8_t>(parPad))
@ -309,7 +309,7 @@ namespace dhandy::bt {
} }
struct TigerBlock { struct TigerBlock {
constexpr explicit TigerBlock ( const char* parStr ) : consteval explicit TigerBlock ( const char* parStr ) :
data{ data{
buff_to_uint64_with_filling(parStr + sizeof(uint64_t) * 0, sizeof(uint64_t)), buff_to_uint64_with_filling(parStr + sizeof(uint64_t) * 0, sizeof(uint64_t)),
buff_to_uint64_with_filling(parStr + sizeof(uint64_t) * 1, sizeof(uint64_t)), buff_to_uint64_with_filling(parStr + sizeof(uint64_t) * 1, sizeof(uint64_t)),
@ -322,12 +322,12 @@ namespace dhandy::bt {
} }
{ {
} }
constexpr TigerBlock ( const TigerBlock& ) = default; consteval TigerBlock ( const TigerBlock& ) = default;
constexpr TigerBlock ( uint64_t a, uint64_t b, uint64_t c, uint64_t d, uint64_t e, uint64_t f, uint64_t g, uint64_t h) : consteval TigerBlock ( uint64_t a, uint64_t b, uint64_t c, uint64_t d, uint64_t e, uint64_t f, uint64_t g, uint64_t h) :
data{a, b, c, d, e, f, g, h} data{a, b, c, d, e, f, g, h}
{ {
} }
constexpr TigerBlock ( const char* parStr, uint64_t parLen, char parPad ) : consteval TigerBlock ( const char* parStr, uint64_t parLen, char parPad ) :
data{ data{
buff_to_uint64_fill_ifn(parStr, 0, parLen, parPad), buff_to_uint64_fill_ifn(parStr, 0, parLen, parPad),
buff_to_uint64_fill_ifn(parStr, 1, parLen, parPad), buff_to_uint64_fill_ifn(parStr, 1, parLen, parPad),
@ -340,7 +340,7 @@ namespace dhandy::bt {
} }
{ {
} }
constexpr TigerBlock ( const char* parStr, uint64_t parLen, char parPad, uint64_t parData7 ) : consteval TigerBlock ( const char* parStr, uint64_t parLen, char parPad, uint64_t parData7 ) :
data{ data{
buff_to_uint64_fill_ifn(parStr, 0, parLen, parPad), buff_to_uint64_fill_ifn(parStr, 0, parLen, parPad),
buff_to_uint64_fill_ifn(parStr, 1, parLen, parPad), buff_to_uint64_fill_ifn(parStr, 1, parLen, parPad),
@ -354,16 +354,16 @@ namespace dhandy::bt {
{ {
} }
constexpr uint64_t operator[] (std::size_t parIndex) const { return (parIndex < lengthof(data) ? data[parIndex] : throw 0); } consteval uint64_t operator[] (std::size_t parIndex) const { return (parIndex < lengthof(data) ? data[parIndex] : throw 0); }
const uint64_t data[8]; const uint64_t data[8];
}; };
constexpr uint64_t gb (uint64_t r, uint64_t a) { consteval uint64_t gb (uint64_t r, uint64_t a) {
return (r >> (a * CHAR_BIT)) bitand 0xff; return (r >> (a * CHAR_BIT)) bitand 0xff;
} }
constexpr HashType round (uint64_t mul, uint64_t a, uint64_t b, uint64_t c, uint64_t x, const TigerBlock& block, const HashType& hash) { consteval HashType round (uint64_t mul, uint64_t a, uint64_t b, uint64_t c, uint64_t x, const TigerBlock& block, const HashType& hash) {
return HashType( return HashType(
a, a,
hash[a] - ( hash[a] - (
@ -382,7 +382,7 @@ namespace dhandy::bt {
); );
} }
constexpr HashType pass (uint64_t a, uint64_t b, uint64_t c, uint64_t mul, const TigerBlock& block, const HashType& hash, uint64_t x=0) { consteval HashType pass (uint64_t a, uint64_t b, uint64_t c, uint64_t mul, const TigerBlock& block, const HashType& hash, uint64_t x=0) {
return ( return (
8 == x ? 8 == x ?
//if 0 == x //if 0 == x
@ -400,25 +400,25 @@ namespace dhandy::bt {
); );
} }
template <uint64_t I, uint64_t S> constexpr uint64_t key_sched_op (const TigerBlock& i); template <uint64_t I, uint64_t S> consteval uint64_t key_sched_op (const TigerBlock& i);
template<> constexpr uint64_t key_sched_op<0,1> (const TigerBlock& i) { return i[0] - (i[7] ^ 0xA5A5A5A5A5A5A5A5ULL); } template<> consteval uint64_t key_sched_op<0,1> (const TigerBlock& i) { return i[0] - (i[7] ^ 0xA5A5A5A5A5A5A5A5ULL); }
template<> constexpr uint64_t key_sched_op<1,1> (const TigerBlock& i) { return i[1] ^ key_sched_op<0,1>(i); } template<> consteval uint64_t key_sched_op<1,1> (const TigerBlock& i) { return i[1] ^ key_sched_op<0,1>(i); }
template<> constexpr uint64_t key_sched_op<2,1> (const TigerBlock& i) { return i[2] + key_sched_op<1,1>(i); } template<> consteval uint64_t key_sched_op<2,1> (const TigerBlock& i) { return i[2] + key_sched_op<1,1>(i); }
template<> constexpr uint64_t key_sched_op<3,1> (const TigerBlock& i) { return i[3] - (key_sched_op<2,1>(i) ^ ((~key_sched_op<1,1>(i)) << 19)); } template<> consteval uint64_t key_sched_op<3,1> (const TigerBlock& i) { return i[3] - (key_sched_op<2,1>(i) ^ ((~key_sched_op<1,1>(i)) << 19)); }
template<> constexpr uint64_t key_sched_op<4,1> (const TigerBlock& i) { return i[4] ^ key_sched_op<3,1>(i); } template<> consteval uint64_t key_sched_op<4,1> (const TigerBlock& i) { return i[4] ^ key_sched_op<3,1>(i); }
template<> constexpr uint64_t key_sched_op<5,1> (const TigerBlock& i) { return i[5] + key_sched_op<4,1>(i); } template<> consteval uint64_t key_sched_op<5,1> (const TigerBlock& i) { return i[5] + key_sched_op<4,1>(i); }
template<> constexpr uint64_t key_sched_op<6,1> (const TigerBlock& i) { return i[6] - (key_sched_op<5,1>(i) ^ ((~key_sched_op<4,1>(i)) >> 23)); } template<> consteval uint64_t key_sched_op<6,1> (const TigerBlock& i) { return i[6] - (key_sched_op<5,1>(i) ^ ((~key_sched_op<4,1>(i)) >> 23)); }
template<> constexpr uint64_t key_sched_op<7,1> (const TigerBlock& i) { return i[7] ^ key_sched_op<6,1>(i); } template<> consteval uint64_t key_sched_op<7,1> (const TigerBlock& i) { return i[7] ^ key_sched_op<6,1>(i); }
template<> constexpr uint64_t key_sched_op<0,2> (const TigerBlock& i) { return key_sched_op<0,1>(i) + key_sched_op<7,1>(i); } template<> consteval uint64_t key_sched_op<0,2> (const TigerBlock& i) { return key_sched_op<0,1>(i) + key_sched_op<7,1>(i); }
template<> constexpr uint64_t key_sched_op<1,2> (const TigerBlock& i) { return key_sched_op<1,1>(i) - (key_sched_op<0,2>(i) ^ ((~key_sched_op<7,1>(i)) << 19)); } template<> consteval uint64_t key_sched_op<1,2> (const TigerBlock& i) { return key_sched_op<1,1>(i) - (key_sched_op<0,2>(i) ^ ((~key_sched_op<7,1>(i)) << 19)); }
template<> constexpr uint64_t key_sched_op<2,2> (const TigerBlock& i) { return key_sched_op<2,1>(i) ^ key_sched_op<1,2>(i); } template<> consteval uint64_t key_sched_op<2,2> (const TigerBlock& i) { return key_sched_op<2,1>(i) ^ key_sched_op<1,2>(i); }
template<> constexpr uint64_t key_sched_op<3,2> (const TigerBlock& i) { return key_sched_op<3,1>(i) + key_sched_op<2,2>(i); } template<> consteval uint64_t key_sched_op<3,2> (const TigerBlock& i) { return key_sched_op<3,1>(i) + key_sched_op<2,2>(i); }
template<> constexpr uint64_t key_sched_op<4,2> (const TigerBlock& i) { return key_sched_op<4,1>(i) - (key_sched_op<3,2>(i) ^ ((~key_sched_op<2,2>(i)) >> 23)); } template<> consteval uint64_t key_sched_op<4,2> (const TigerBlock& i) { return key_sched_op<4,1>(i) - (key_sched_op<3,2>(i) ^ ((~key_sched_op<2,2>(i)) >> 23)); }
template<> constexpr uint64_t key_sched_op<5,2> (const TigerBlock& i) { return key_sched_op<5,1>(i) ^ key_sched_op<4,2>(i); } template<> consteval uint64_t key_sched_op<5,2> (const TigerBlock& i) { return key_sched_op<5,1>(i) ^ key_sched_op<4,2>(i); }
template<> constexpr uint64_t key_sched_op<6,2> (const TigerBlock& i) { return key_sched_op<6,1>(i) + key_sched_op<5,2>(i); } template<> consteval uint64_t key_sched_op<6,2> (const TigerBlock& i) { return key_sched_op<6,1>(i) + key_sched_op<5,2>(i); }
template<> constexpr uint64_t key_sched_op<7,2> (const TigerBlock& i) { return key_sched_op<7,1>(i) - (key_sched_op<6,2>(i) ^ 0x0123456789ABCDEFULL); } template<> consteval uint64_t key_sched_op<7,2> (const TigerBlock& i) { return key_sched_op<7,1>(i) - (key_sched_op<6,2>(i) ^ 0x0123456789ABCDEFULL); }
constexpr TigerBlock key_sched (const TigerBlock& parBlock) { consteval TigerBlock key_sched (const TigerBlock& parBlock) {
return TigerBlock( return TigerBlock(
key_sched_op<0,2>(parBlock), key_sched_op<0,2>(parBlock),
key_sched_op<1,2>(parBlock), key_sched_op<1,2>(parBlock),
@ -431,7 +431,7 @@ namespace dhandy::bt {
); );
} }
constexpr HashType finalize_tiger_step (HashType parOriginal, HashType parPartial) { consteval HashType finalize_tiger_step (HashType parOriginal, HashType parPartial) {
return HashType( return HashType(
parPartial.a ^ parOriginal.a, parPartial.a ^ parOriginal.a,
parPartial.b - parOriginal.b, parPartial.b - parOriginal.b,
@ -439,7 +439,7 @@ namespace dhandy::bt {
); );
} }
constexpr HashType tiger_block (const TigerBlock& parBlock, HashType parHash) { consteval HashType tiger_block (const TigerBlock& parBlock, HashType parHash) {
return finalize_tiger_step( return finalize_tiger_step(
parHash, parHash,
pass(1, 2, 0, 9, key_sched(key_sched(parBlock)), pass(1, 2, 0, 9, key_sched(key_sched(parBlock)),
@ -450,11 +450,11 @@ namespace dhandy::bt {
); );
} }
constexpr HashType tiger_block (const char* parStr, HashType parHash) { consteval HashType tiger_block (const char* parStr, HashType parHash) {
return tiger_block(TigerBlock(parStr), parHash); return tiger_block(TigerBlock(parStr), parHash);
} }
constexpr HashType tiger_chunk (const char* parStr, uint64_t parLen, HashType parHash) { consteval HashType tiger_chunk (const char* parStr, uint64_t parLen, HashType parHash) {
return (parLen == 0 ? return (parLen == 0 ?
//if parLen == 0 //if parLen == 0
parHash parHash
@ -464,7 +464,7 @@ namespace dhandy::bt {
); );
} }
constexpr HashType tiger_last_chunk (const char* parStr, uint64_t parLen, uint64_t parRealLen, HashType parHash, char parPad) { consteval HashType tiger_last_chunk (const char* parStr, uint64_t parLen, uint64_t parRealLen, HashType parHash, char parPad) {
return ( return (
parLen + 1 + ((8 - parLen - 1) bitand 7) == 64 ? parLen + 1 + ((8 - parLen - 1) bitand 7) == 64 ?
tiger_block( tiger_block(
@ -477,7 +477,7 @@ namespace dhandy::bt {
} }
} //namespace implem } //namespace implem
constexpr HashType tiger (const char* parStr, uint64_t parLen, char parPad) { consteval HashType tiger (const char* parStr, uint64_t parLen, char parPad) {
return implem::tiger_last_chunk( return implem::tiger_last_chunk(
parStr + (parLen bitand ~static_cast<uint64_t>(0x3f)), parStr + (parLen bitand ~static_cast<uint64_t>(0x3f)),
parLen - (parLen bitand ~static_cast<uint64_t>(0x3f)), parLen - (parLen bitand ~static_cast<uint64_t>(0x3f)),