mirror of
https://github.com/XRPLF/rippled.git
synced 2025-12-06 17:27:55 +00:00
beast cleanup and tidying:
* Replace custom types with C++11 <cstdint> types * Fix sqlite integer intos and uses * Fix String implicit integer constructors * Escape the enclosing namespace in sqdb * Replace contract checks with assert * Make many header files compile independently * Remove the dependence on beast_core.h in many places * Remove unused or obsolete classes and functions * Remove unused or obsolete macros * Remove unused network functions and files * Remove unused or obsolete classes: - ChildProcess - HighResolutionTimer - InterProcessLock - Throw - TrackedMutex - UntrackedMutex - XmlDocument - XmlElement
This commit is contained in:
Vinnie Falco
@@ -42,12 +42,12 @@ namespace Murmur {
|
||||
|
||||
#else
|
||||
|
||||
static inline uint32_t rotl32 ( uint32_t x, int8_t r )
|
||||
static inline std::uint32_t rotl32 ( std::uint32_t x, int8_t r )
|
||||
{
|
||||
return (x << r) | (x >> (32 - r));
|
||||
}
|
||||
|
||||
static inline uint64_t rotl64 ( uint64_t x, int8_t r )
|
||||
static inline std::uint64_t rotl64 ( std::uint64_t x, int8_t r )
|
||||
{
|
||||
return (x << r) | (x >> (64 - r));
|
||||
}
|
||||
@@ -63,12 +63,12 @@ static inline uint64_t rotl64 ( uint64_t x, int8_t r )
|
||||
// Block read - if your platform needs to do endian-swapping or can only
|
||||
// handle aligned reads, do the conversion here
|
||||
|
||||
static forcedinline uint32_t getblock ( const uint32_t* p, int i )
|
||||
static inline std::uint32_t getblock ( const std::uint32_t* p, int i )
|
||||
{
|
||||
return p[i];
|
||||
}
|
||||
|
||||
static forcedinline uint64_t getblock ( const uint64_t* p, int i )
|
||||
static inline std::uint64_t getblock ( const std::uint64_t* p, int i )
|
||||
{
|
||||
return p[i];
|
||||
}
|
||||
@@ -76,7 +76,7 @@ static forcedinline uint64_t getblock ( const uint64_t* p, int i )
|
||||
//-----------------------------------------------------------------------------
|
||||
// Finalization mix - force all bits of a hash block to avalanche
|
||||
|
||||
static forcedinline uint32_t fmix ( uint32_t h )
|
||||
static inline std::uint32_t fmix ( std::uint32_t h )
|
||||
{
|
||||
h ^= h >> 16;
|
||||
h *= 0x85ebca6b;
|
||||
@@ -89,7 +89,7 @@ static forcedinline uint32_t fmix ( uint32_t h )
|
||||
|
||||
//----------
|
||||
|
||||
static forcedinline uint64_t fmix ( uint64_t k )
|
||||
static inline std::uint64_t fmix ( std::uint64_t k )
|
||||
{
|
||||
k ^= k >> 33;
|
||||
k *= BIG_CONSTANT (0xff51afd7ed558ccd);
|
||||
@@ -103,24 +103,24 @@ static forcedinline uint64_t fmix ( uint64_t k )
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
void MurmurHash3_x86_32 ( const void* key, int len,
|
||||
uint32_t seed, void* out )
|
||||
std::uint32_t seed, void* out )
|
||||
{
|
||||
const uint8_t* data = (const uint8_t*)key;
|
||||
const int nblocks = len / 4;
|
||||
|
||||
uint32_t h1 = seed;
|
||||
std::uint32_t h1 = seed;
|
||||
|
||||
uint32_t c1 = 0xcc9e2d51;
|
||||
uint32_t c2 = 0x1b873593;
|
||||
std::uint32_t c1 = 0xcc9e2d51;
|
||||
std::uint32_t c2 = 0x1b873593;
|
||||
|
||||
//----------
|
||||
// body
|
||||
|
||||
const uint32_t* blocks = (const uint32_t*) (data + nblocks * 4);
|
||||
const std::uint32_t* blocks = (const std::uint32_t*) (data + nblocks * 4);
|
||||
|
||||
for (int i = -nblocks; i; i++)
|
||||
{
|
||||
uint32_t k1 = getblock (blocks, i);
|
||||
std::uint32_t k1 = getblock (blocks, i);
|
||||
|
||||
k1 *= c1;
|
||||
k1 = ROTL32 (k1, 15);
|
||||
@@ -136,7 +136,7 @@ void MurmurHash3_x86_32 ( const void* key, int len,
|
||||
|
||||
const uint8_t* tail = (const uint8_t*) (data + nblocks * 4);
|
||||
|
||||
uint32_t k1 = 0;
|
||||
std::uint32_t k1 = 0;
|
||||
|
||||
switch (len & 3)
|
||||
{
|
||||
@@ -161,38 +161,38 @@ void MurmurHash3_x86_32 ( const void* key, int len,
|
||||
|
||||
h1 = fmix (h1);
|
||||
|
||||
* (uint32_t*)out = h1;
|
||||
* (std::uint32_t*)out = h1;
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
void MurmurHash3_x86_128 ( const void* key, const int len,
|
||||
uint32_t seed, void* out )
|
||||
std::uint32_t seed, void* out )
|
||||
{
|
||||
const uint8_t* data = (const uint8_t*)key;
|
||||
const int nblocks = len / 16;
|
||||
|
||||
uint32_t h1 = seed;
|
||||
uint32_t h2 = seed;
|
||||
uint32_t h3 = seed;
|
||||
uint32_t h4 = seed;
|
||||
std::uint32_t h1 = seed;
|
||||
std::uint32_t h2 = seed;
|
||||
std::uint32_t h3 = seed;
|
||||
std::uint32_t h4 = seed;
|
||||
|
||||
uint32_t c1 = 0x239b961b;
|
||||
uint32_t c2 = 0xab0e9789;
|
||||
uint32_t c3 = 0x38b34ae5;
|
||||
uint32_t c4 = 0xa1e38b93;
|
||||
std::uint32_t c1 = 0x239b961b;
|
||||
std::uint32_t c2 = 0xab0e9789;
|
||||
std::uint32_t c3 = 0x38b34ae5;
|
||||
std::uint32_t c4 = 0xa1e38b93;
|
||||
|
||||
//----------
|
||||
// body
|
||||
|
||||
const uint32_t* blocks = (const uint32_t*) (data + nblocks * 16);
|
||||
const std::uint32_t* blocks = (const std::uint32_t*) (data + nblocks * 16);
|
||||
|
||||
for (int i = -nblocks; i; i++)
|
||||
{
|
||||
uint32_t k1 = getblock (blocks, i * 4 + 0);
|
||||
uint32_t k2 = getblock (blocks, i * 4 + 1);
|
||||
uint32_t k3 = getblock (blocks, i * 4 + 2);
|
||||
uint32_t k4 = getblock (blocks, i * 4 + 3);
|
||||
std::uint32_t k1 = getblock (blocks, i * 4 + 0);
|
||||
std::uint32_t k2 = getblock (blocks, i * 4 + 1);
|
||||
std::uint32_t k3 = getblock (blocks, i * 4 + 2);
|
||||
std::uint32_t k4 = getblock (blocks, i * 4 + 3);
|
||||
|
||||
k1 *= c1;
|
||||
k1 = ROTL32 (k1, 15);
|
||||
@@ -236,10 +236,10 @@ void MurmurHash3_x86_128 ( const void* key, const int len,
|
||||
|
||||
const uint8_t* tail = (const uint8_t*) (data + nblocks * 16);
|
||||
|
||||
uint32_t k1 = 0;
|
||||
uint32_t k2 = 0;
|
||||
uint32_t k3 = 0;
|
||||
uint32_t k4 = 0;
|
||||
std::uint32_t k1 = 0;
|
||||
std::uint32_t k2 = 0;
|
||||
std::uint32_t k3 = 0;
|
||||
std::uint32_t k4 = 0;
|
||||
|
||||
switch (len & 15)
|
||||
{
|
||||
@@ -348,38 +348,38 @@ void MurmurHash3_x86_128 ( const void* key, const int len,
|
||||
|
||||
h4 += h1;
|
||||
|
||||
((uint32_t*)out)[0] = h1;
|
||||
((std::uint32_t*)out)[0] = h1;
|
||||
|
||||
((uint32_t*)out)[1] = h2;
|
||||
((std::uint32_t*)out)[1] = h2;
|
||||
|
||||
((uint32_t*)out)[2] = h3;
|
||||
((std::uint32_t*)out)[2] = h3;
|
||||
|
||||
((uint32_t*)out)[3] = h4;
|
||||
((std::uint32_t*)out)[3] = h4;
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
void MurmurHash3_x64_128 ( const void* key, const int len,
|
||||
const uint32_t seed, void* out )
|
||||
const std::uint32_t seed, void* out )
|
||||
{
|
||||
const uint8_t* data = (const uint8_t*)key;
|
||||
const int nblocks = len / 16;
|
||||
|
||||
uint64_t h1 = seed;
|
||||
uint64_t h2 = seed;
|
||||
std::uint64_t h1 = seed;
|
||||
std::uint64_t h2 = seed;
|
||||
|
||||
uint64_t c1 = BIG_CONSTANT (0x87c37b91114253d5);
|
||||
uint64_t c2 = BIG_CONSTANT (0x4cf5ad432745937f);
|
||||
std::uint64_t c1 = BIG_CONSTANT (0x87c37b91114253d5);
|
||||
std::uint64_t c2 = BIG_CONSTANT (0x4cf5ad432745937f);
|
||||
|
||||
//----------
|
||||
// body
|
||||
|
||||
const uint64_t* blocks = (const uint64_t*) (data);
|
||||
const std::uint64_t* blocks = (const std::uint64_t*) (data);
|
||||
|
||||
for (int i = 0; i < nblocks; i++)
|
||||
{
|
||||
uint64_t k1 = getblock (blocks, i * 2 + 0);
|
||||
uint64_t k2 = getblock (blocks, i * 2 + 1);
|
||||
std::uint64_t k1 = getblock (blocks, i * 2 + 0);
|
||||
std::uint64_t k2 = getblock (blocks, i * 2 + 1);
|
||||
|
||||
k1 *= c1;
|
||||
k1 = ROTL64 (k1, 31);
|
||||
@@ -405,59 +405,59 @@ void MurmurHash3_x64_128 ( const void* key, const int len,
|
||||
|
||||
const uint8_t* tail = (const uint8_t*) (data + nblocks * 16);
|
||||
|
||||
uint64_t k1 = 0;
|
||||
uint64_t k2 = 0;
|
||||
std::uint64_t k1 = 0;
|
||||
std::uint64_t k2 = 0;
|
||||
|
||||
switch (len & 15)
|
||||
{
|
||||
case 15:
|
||||
k2 ^= uint64_t (tail[14]) << 48;
|
||||
k2 ^= std::uint64_t (tail[14]) << 48;
|
||||
|
||||
case 14:
|
||||
k2 ^= uint64_t (tail[13]) << 40;
|
||||
k2 ^= std::uint64_t (tail[13]) << 40;
|
||||
|
||||
case 13:
|
||||
k2 ^= uint64_t (tail[12]) << 32;
|
||||
k2 ^= std::uint64_t (tail[12]) << 32;
|
||||
|
||||
case 12:
|
||||
k2 ^= uint64_t (tail[11]) << 24;
|
||||
k2 ^= std::uint64_t (tail[11]) << 24;
|
||||
|
||||
case 11:
|
||||
k2 ^= uint64_t (tail[10]) << 16;
|
||||
k2 ^= std::uint64_t (tail[10]) << 16;
|
||||
|
||||
case 10:
|
||||
k2 ^= uint64_t (tail[ 9]) << 8;
|
||||
k2 ^= std::uint64_t (tail[ 9]) << 8;
|
||||
|
||||
case 9:
|
||||
k2 ^= uint64_t (tail[ 8]) << 0;
|
||||
k2 ^= std::uint64_t (tail[ 8]) << 0;
|
||||
k2 *= c2;
|
||||
k2 = ROTL64 (k2, 33);
|
||||
k2 *= c1;
|
||||
h2 ^= k2;
|
||||
|
||||
case 8:
|
||||
k1 ^= uint64_t (tail[ 7]) << 56;
|
||||
k1 ^= std::uint64_t (tail[ 7]) << 56;
|
||||
|
||||
case 7:
|
||||
k1 ^= uint64_t (tail[ 6]) << 48;
|
||||
k1 ^= std::uint64_t (tail[ 6]) << 48;
|
||||
|
||||
case 6:
|
||||
k1 ^= uint64_t (tail[ 5]) << 40;
|
||||
k1 ^= std::uint64_t (tail[ 5]) << 40;
|
||||
|
||||
case 5:
|
||||
k1 ^= uint64_t (tail[ 4]) << 32;
|
||||
k1 ^= std::uint64_t (tail[ 4]) << 32;
|
||||
|
||||
case 4:
|
||||
k1 ^= uint64_t (tail[ 3]) << 24;
|
||||
k1 ^= std::uint64_t (tail[ 3]) << 24;
|
||||
|
||||
case 3:
|
||||
k1 ^= uint64_t (tail[ 2]) << 16;
|
||||
k1 ^= std::uint64_t (tail[ 2]) << 16;
|
||||
|
||||
case 2:
|
||||
k1 ^= uint64_t (tail[ 1]) << 8;
|
||||
k1 ^= std::uint64_t (tail[ 1]) << 8;
|
||||
|
||||
case 1:
|
||||
k1 ^= uint64_t (tail[ 0]) << 0;
|
||||
k1 ^= std::uint64_t (tail[ 0]) << 0;
|
||||
k1 *= c1;
|
||||
k1 = ROTL64 (k1, 31);
|
||||
k1 *= c2;
|
||||
@@ -483,9 +483,9 @@ void MurmurHash3_x64_128 ( const void* key, const int len,
|
||||
|
||||
h2 += h1;
|
||||
|
||||
((uint64_t*)out)[0] = h1;
|
||||
((std::uint64_t*)out)[0] = h1;
|
||||
|
||||
((uint64_t*)out)[1] = h2;
|
||||
((std::uint64_t*)out)[1] = h2;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
@@ -49,12 +49,12 @@ Context::Context ()
|
||||
|
||||
void Context::update (void const* buffer, std::size_t bytes)
|
||||
{
|
||||
detail::SHA256_Update (&m_context, static_cast <uint8 const*> (buffer), bytes);
|
||||
detail::SHA256_Update (&m_context, static_cast <std::uint8_t const*> (buffer), bytes);
|
||||
}
|
||||
|
||||
void* Context::finish (void* hash)
|
||||
{
|
||||
detail::SHA256_Final (static_cast <uint8*> (hash), &m_context);
|
||||
detail::SHA256_Final (static_cast <std::uint8_t*> (hash), &m_context);
|
||||
return hash;
|
||||
}
|
||||
|
||||
@@ -66,7 +66,7 @@ digest_type const& empty_digest()
|
||||
{
|
||||
Holder ()
|
||||
{
|
||||
uint8 zero (0);
|
||||
std::uint8_t zero (0);
|
||||
hash (zero, digest);
|
||||
}
|
||||
|
||||
@@ -99,24 +99,24 @@ digest_type hash (void const* buffer, std::size_t bytes)
|
||||
return digest;
|
||||
}
|
||||
|
||||
void* hash (int8 const* begin, int8 const* end, void* digest)
|
||||
void* hash (std::int8_t const* begin, std::int8_t const* end, void* digest)
|
||||
{
|
||||
return hash (begin, end - begin, digest);
|
||||
}
|
||||
|
||||
void* hash (uint8 const* begin, uint8 const* end, void* digest)
|
||||
void* hash (std::uint8_t const* begin, std::uint8_t const* end, void* digest)
|
||||
{
|
||||
return hash (begin, end - begin, digest);
|
||||
}
|
||||
|
||||
digest_type hash (int8 const* begin, int8 const* end)
|
||||
digest_type hash (std::int8_t const* begin, std::int8_t const* end)
|
||||
{
|
||||
digest_type digest;
|
||||
hash (begin, end - begin, digest);
|
||||
return digest;
|
||||
}
|
||||
|
||||
digest_type hash (uint8 const* begin, uint8 const* end)
|
||||
digest_type hash (std::uint8_t const* begin, std::uint8_t const* end)
|
||||
{
|
||||
digest_type digest;
|
||||
hash (begin, end - begin, digest);
|
||||
|
||||
@@ -103,9 +103,9 @@
|
||||
* types and pointing out recent ANSI C support for uintXX_t in inttypes.h.
|
||||
*/
|
||||
|
||||
typedef uint8 sha2_byte; /* Exactly 1 byte */
|
||||
typedef uint32 sha2_word32; /* Exactly 4 bytes */
|
||||
typedef uint64 sha2_word64; /* Exactly 8 bytes */
|
||||
typedef std::uint8_t sha2_byte; /* Exactly 1 byte */
|
||||
typedef std::uint32_t sha2_word32; /* Exactly 4 bytes */
|
||||
typedef std::uint64_t sha2_word64; /* Exactly 8 bytes */
|
||||
|
||||
/*** SHA-256/384/512 Various Length Definitions ***********************/
|
||||
/* NOTE: Most of these are in sha2.h */
|
||||
|
||||
@@ -58,9 +58,9 @@
|
||||
|
||||
/*** SHA-256/384/512 Context Structures *******************************/
|
||||
typedef struct _SHA512_CTX {
|
||||
uint64 state[8];
|
||||
uint64 bitcount[2];
|
||||
uint8 buffer[SHA512_BLOCK_LENGTH];
|
||||
std::uint64_t state[8];
|
||||
std::uint64_t bitcount[2];
|
||||
std::uint8_t buffer[SHA512_BLOCK_LENGTH];
|
||||
} SHA512_CTX;
|
||||
|
||||
typedef SHA512_CTX SHA384_CTX;
|
||||
@@ -70,22 +70,22 @@ typedef SHA512_CTX SHA384_CTX;
|
||||
#ifndef NOPROTO
|
||||
|
||||
void SHA256_Init(Sha256::detail::Context *);
|
||||
void SHA256_Update(Sha256::detail::Context*, const uint8*, size_t);
|
||||
void SHA256_Final(uint8[Sha256::digestLength], Sha256::detail::Context*);
|
||||
void SHA256_Update(Sha256::detail::Context*, const std::uint8_t*, size_t);
|
||||
void SHA256_Final(std::uint8_t[Sha256::digestLength], Sha256::detail::Context*);
|
||||
char* SHA256_End(Sha256::detail::Context*, char[SHA256_DIGEST_STRING_LENGTH]);
|
||||
char* SHA256_Data(const uint8*, size_t, char[SHA256_DIGEST_STRING_LENGTH]);
|
||||
char* SHA256_Data(const std::uint8_t*, size_t, char[SHA256_DIGEST_STRING_LENGTH]);
|
||||
|
||||
void SHA384_Init(SHA384_CTX*);
|
||||
void SHA384_Update(SHA384_CTX*, const uint8*, size_t);
|
||||
void SHA384_Final(uint8[SHA384_DIGEST_LENGTH], SHA384_CTX*);
|
||||
void SHA384_Update(SHA384_CTX*, const std::uint8_t*, size_t);
|
||||
void SHA384_Final(std::uint8_t[SHA384_DIGEST_LENGTH], SHA384_CTX*);
|
||||
char* SHA384_End(SHA384_CTX*, char[SHA384_DIGEST_STRING_LENGTH]);
|
||||
char* SHA384_Data(const uint8*, size_t, char[SHA384_DIGEST_STRING_LENGTH]);
|
||||
char* SHA384_Data(const std::uint8_t*, size_t, char[SHA384_DIGEST_STRING_LENGTH]);
|
||||
|
||||
void SHA512_Init(SHA512_CTX*);
|
||||
void SHA512_Update(SHA512_CTX*, const uint8*, size_t);
|
||||
void SHA512_Final(uint8[SHA512_DIGEST_LENGTH], SHA512_CTX*);
|
||||
void SHA512_Update(SHA512_CTX*, const std::uint8_t*, size_t);
|
||||
void SHA512_Final(std::uint8_t[SHA512_DIGEST_LENGTH], SHA512_CTX*);
|
||||
char* SHA512_End(SHA512_CTX*, char[SHA512_DIGEST_STRING_LENGTH]);
|
||||
char* SHA512_Data(const uint8*, size_t, char[SHA512_DIGEST_STRING_LENGTH]);
|
||||
char* SHA512_Data(const std::uint8_t*, size_t, char[SHA512_DIGEST_STRING_LENGTH]);
|
||||
|
||||
#else /* NOPROTO */
|
||||
|
||||
|
||||
Reference in New Issue
Block a user