ARCHIVE/rippled
1
0
Fork 0
mirror of https://github.com/XRPLF/rippled.git synced 2025-11-29 07:25:51 +00:00
Code Issues Packages Projects Releases Wiki Activity

beast cleanup and tidying:

Browse Source 
* 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
2014-03-22 09:43:11 -07:00
parent 5eb0aa2765
commit 3fbff6e620
203 changed files with 1427 additions and 7889 deletions
Download Patch File Download Diff File Expand all files Collapse all files

126
beast/crypto/impl/MurmurHash.cpp
View File

@@ -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;
}
}