67a42f929b
This introduces CNetAddr and CService, respectively wrapping an
(IPv6) IP address and an IP+port combination. This functionality used
to be part of CAddress, which also contains network flags and
connection attempt information. These extra fields are however not
always necessary.
These classes, along with logic for creating connections and doing
name lookups, are moved to netbase.{h,cpp}, which does not depend on
headers.h.
Furthermore, CNetAddr is mostly IPv6-ready, though IPv6
functionality is not yet enabled for the application itself.
761 lines
24 KiB
C++
761 lines
24 KiB
C++
// Copyright (c) 2009-2010 Satoshi Nakamoto
|
|
// Copyright (c) 2011 The Bitcoin developers
|
|
// Distributed under the MIT/X11 software license, see the accompanying
|
|
// file license.txt or http://www.opensource.org/licenses/mit-license.php.
|
|
#ifndef BITCOIN_UINT256_H
|
|
#define BITCOIN_UINT256_H
|
|
|
|
#include "serialize.h"
|
|
|
|
#include <limits.h>
|
|
#include <string>
|
|
#include <vector>
|
|
|
|
typedef long long int64;
|
|
typedef unsigned long long uint64;
|
|
|
|
|
|
inline int Testuint256AdHoc(std::vector<std::string> vArg);
|
|
|
|
|
|
|
|
// We have to keep a separate base class without constructors
|
|
// so the compiler will let us use it in a union
|
|
template<unsigned int BITS>
|
|
class base_uint
|
|
{
|
|
protected:
|
|
enum { WIDTH=BITS/32 };
|
|
unsigned int pn[WIDTH];
|
|
public:
|
|
|
|
bool operator!() const
|
|
{
|
|
for (int i = 0; i < WIDTH; i++)
|
|
if (pn[i] != 0)
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
const base_uint operator~() const
|
|
{
|
|
base_uint ret;
|
|
for (int i = 0; i < WIDTH; i++)
|
|
ret.pn[i] = ~pn[i];
|
|
return ret;
|
|
}
|
|
|
|
const base_uint operator-() const
|
|
{
|
|
base_uint ret;
|
|
for (int i = 0; i < WIDTH; i++)
|
|
ret.pn[i] = ~pn[i];
|
|
ret++;
|
|
return ret;
|
|
}
|
|
|
|
|
|
base_uint& operator=(uint64 b)
|
|
{
|
|
pn[0] = (unsigned int)b;
|
|
pn[1] = (unsigned int)(b >> 32);
|
|
for (int i = 2; i < WIDTH; i++)
|
|
pn[i] = 0;
|
|
return *this;
|
|
}
|
|
|
|
base_uint& operator^=(const base_uint& b)
|
|
{
|
|
for (int i = 0; i < WIDTH; i++)
|
|
pn[i] ^= b.pn[i];
|
|
return *this;
|
|
}
|
|
|
|
base_uint& operator&=(const base_uint& b)
|
|
{
|
|
for (int i = 0; i < WIDTH; i++)
|
|
pn[i] &= b.pn[i];
|
|
return *this;
|
|
}
|
|
|
|
base_uint& operator|=(const base_uint& b)
|
|
{
|
|
for (int i = 0; i < WIDTH; i++)
|
|
pn[i] |= b.pn[i];
|
|
return *this;
|
|
}
|
|
|
|
base_uint& operator^=(uint64 b)
|
|
{
|
|
pn[0] ^= (unsigned int)b;
|
|
pn[1] ^= (unsigned int)(b >> 32);
|
|
return *this;
|
|
}
|
|
|
|
base_uint& operator&=(uint64 b)
|
|
{
|
|
pn[0] &= (unsigned int)b;
|
|
pn[1] &= (unsigned int)(b >> 32);
|
|
return *this;
|
|
}
|
|
|
|
base_uint& operator|=(uint64 b)
|
|
{
|
|
pn[0] |= (unsigned int)b;
|
|
pn[1] |= (unsigned int)(b >> 32);
|
|
return *this;
|
|
}
|
|
|
|
base_uint& operator<<=(unsigned int shift)
|
|
{
|
|
base_uint a(*this);
|
|
for (int i = 0; i < WIDTH; i++)
|
|
pn[i] = 0;
|
|
int k = shift / 32;
|
|
shift = shift % 32;
|
|
for (int i = 0; i < WIDTH; i++)
|
|
{
|
|
if (i+k+1 < WIDTH && shift != 0)
|
|
pn[i+k+1] |= (a.pn[i] >> (32-shift));
|
|
if (i+k < WIDTH)
|
|
pn[i+k] |= (a.pn[i] << shift);
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
base_uint& operator>>=(unsigned int shift)
|
|
{
|
|
base_uint a(*this);
|
|
for (int i = 0; i < WIDTH; i++)
|
|
pn[i] = 0;
|
|
int k = shift / 32;
|
|
shift = shift % 32;
|
|
for (int i = 0; i < WIDTH; i++)
|
|
{
|
|
if (i-k-1 >= 0 && shift != 0)
|
|
pn[i-k-1] |= (a.pn[i] << (32-shift));
|
|
if (i-k >= 0)
|
|
pn[i-k] |= (a.pn[i] >> shift);
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
base_uint& operator+=(const base_uint& b)
|
|
{
|
|
uint64 carry = 0;
|
|
for (int i = 0; i < WIDTH; i++)
|
|
{
|
|
uint64 n = carry + pn[i] + b.pn[i];
|
|
pn[i] = n & 0xffffffff;
|
|
carry = n >> 32;
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
base_uint& operator-=(const base_uint& b)
|
|
{
|
|
*this += -b;
|
|
return *this;
|
|
}
|
|
|
|
base_uint& operator+=(uint64 b64)
|
|
{
|
|
base_uint b;
|
|
b = b64;
|
|
*this += b;
|
|
return *this;
|
|
}
|
|
|
|
base_uint& operator-=(uint64 b64)
|
|
{
|
|
base_uint b;
|
|
b = b64;
|
|
*this += -b;
|
|
return *this;
|
|
}
|
|
|
|
|
|
base_uint& operator++()
|
|
{
|
|
// prefix operator
|
|
int i = 0;
|
|
while (++pn[i] == 0 && i < WIDTH-1)
|
|
i++;
|
|
return *this;
|
|
}
|
|
|
|
const base_uint operator++(int)
|
|
{
|
|
// postfix operator
|
|
const base_uint ret = *this;
|
|
++(*this);
|
|
return ret;
|
|
}
|
|
|
|
base_uint& operator--()
|
|
{
|
|
// prefix operator
|
|
int i = 0;
|
|
while (--pn[i] == -1 && i < WIDTH-1)
|
|
i++;
|
|
return *this;
|
|
}
|
|
|
|
const base_uint operator--(int)
|
|
{
|
|
// postfix operator
|
|
const base_uint ret = *this;
|
|
--(*this);
|
|
return ret;
|
|
}
|
|
|
|
|
|
friend inline bool operator<(const base_uint& a, const base_uint& b)
|
|
{
|
|
for (int i = base_uint::WIDTH-1; i >= 0; i--)
|
|
{
|
|
if (a.pn[i] < b.pn[i])
|
|
return true;
|
|
else if (a.pn[i] > b.pn[i])
|
|
return false;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
friend inline bool operator<=(const base_uint& a, const base_uint& b)
|
|
{
|
|
for (int i = base_uint::WIDTH-1; i >= 0; i--)
|
|
{
|
|
if (a.pn[i] < b.pn[i])
|
|
return true;
|
|
else if (a.pn[i] > b.pn[i])
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
friend inline bool operator>(const base_uint& a, const base_uint& b)
|
|
{
|
|
for (int i = base_uint::WIDTH-1; i >= 0; i--)
|
|
{
|
|
if (a.pn[i] > b.pn[i])
|
|
return true;
|
|
else if (a.pn[i] < b.pn[i])
|
|
return false;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
friend inline bool operator>=(const base_uint& a, const base_uint& b)
|
|
{
|
|
for (int i = base_uint::WIDTH-1; i >= 0; i--)
|
|
{
|
|
if (a.pn[i] > b.pn[i])
|
|
return true;
|
|
else if (a.pn[i] < b.pn[i])
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
friend inline bool operator==(const base_uint& a, const base_uint& b)
|
|
{
|
|
for (int i = 0; i < base_uint::WIDTH; i++)
|
|
if (a.pn[i] != b.pn[i])
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
friend inline bool operator==(const base_uint& a, uint64 b)
|
|
{
|
|
if (a.pn[0] != (unsigned int)b)
|
|
return false;
|
|
if (a.pn[1] != (unsigned int)(b >> 32))
|
|
return false;
|
|
for (int i = 2; i < base_uint::WIDTH; i++)
|
|
if (a.pn[i] != 0)
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
friend inline bool operator!=(const base_uint& a, const base_uint& b)
|
|
{
|
|
return (!(a == b));
|
|
}
|
|
|
|
friend inline bool operator!=(const base_uint& a, uint64 b)
|
|
{
|
|
return (!(a == b));
|
|
}
|
|
|
|
|
|
|
|
std::string GetHex() const
|
|
{
|
|
char psz[sizeof(pn)*2 + 1];
|
|
for (int i = 0; i < sizeof(pn); i++)
|
|
sprintf(psz + i*2, "%02x", ((unsigned char*)pn)[sizeof(pn) - i - 1]);
|
|
return std::string(psz, psz + sizeof(pn)*2);
|
|
}
|
|
|
|
void SetHex(const char* psz)
|
|
{
|
|
for (int i = 0; i < WIDTH; i++)
|
|
pn[i] = 0;
|
|
|
|
// skip leading spaces
|
|
while (isspace(*psz))
|
|
psz++;
|
|
|
|
// skip 0x
|
|
if (psz[0] == '0' && tolower(psz[1]) == 'x')
|
|
psz += 2;
|
|
|
|
// hex string to uint
|
|
static char phexdigit[256] = { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,1,2,3,4,5,6,7,8,9,0,0,0,0,0,0, 0,0xa,0xb,0xc,0xd,0xe,0xf,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0xa,0xb,0xc,0xd,0xe,0xf,0,0,0,0,0,0,0,0,0 };
|
|
const char* pbegin = psz;
|
|
while (phexdigit[*psz] || *psz == '0')
|
|
psz++;
|
|
psz--;
|
|
unsigned char* p1 = (unsigned char*)pn;
|
|
unsigned char* pend = p1 + WIDTH * 4;
|
|
while (psz >= pbegin && p1 < pend)
|
|
{
|
|
*p1 = phexdigit[(unsigned char)*psz--];
|
|
if (psz >= pbegin)
|
|
{
|
|
*p1 |= (phexdigit[(unsigned char)*psz--] << 4);
|
|
p1++;
|
|
}
|
|
}
|
|
}
|
|
|
|
void SetHex(const std::string& str)
|
|
{
|
|
SetHex(str.c_str());
|
|
}
|
|
|
|
std::string ToString() const
|
|
{
|
|
return (GetHex());
|
|
}
|
|
|
|
unsigned char* begin()
|
|
{
|
|
return (unsigned char*)&pn[0];
|
|
}
|
|
|
|
unsigned char* end()
|
|
{
|
|
return (unsigned char*)&pn[WIDTH];
|
|
}
|
|
|
|
unsigned int size()
|
|
{
|
|
return sizeof(pn);
|
|
}
|
|
|
|
|
|
unsigned int GetSerializeSize(int nType=0, int nVersion=PROTOCOL_VERSION) const
|
|
{
|
|
return sizeof(pn);
|
|
}
|
|
|
|
template<typename Stream>
|
|
void Serialize(Stream& s, int nType=0, int nVersion=PROTOCOL_VERSION) const
|
|
{
|
|
s.write((char*)pn, sizeof(pn));
|
|
}
|
|
|
|
template<typename Stream>
|
|
void Unserialize(Stream& s, int nType=0, int nVersion=PROTOCOL_VERSION)
|
|
{
|
|
s.read((char*)pn, sizeof(pn));
|
|
}
|
|
|
|
|
|
friend class uint160;
|
|
friend class uint256;
|
|
friend inline int Testuint256AdHoc(std::vector<std::string> vArg);
|
|
};
|
|
|
|
typedef base_uint<160> base_uint160;
|
|
typedef base_uint<256> base_uint256;
|
|
|
|
|
|
|
|
//
|
|
// uint160 and uint256 could be implemented as templates, but to keep
|
|
// compile errors and debugging cleaner, they're copy and pasted.
|
|
//
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// uint160
|
|
//
|
|
|
|
class uint160 : public base_uint160
|
|
{
|
|
public:
|
|
typedef base_uint160 basetype;
|
|
|
|
uint160()
|
|
{
|
|
for (int i = 0; i < WIDTH; i++)
|
|
pn[i] = 0;
|
|
}
|
|
|
|
uint160(const basetype& b)
|
|
{
|
|
for (int i = 0; i < WIDTH; i++)
|
|
pn[i] = b.pn[i];
|
|
}
|
|
|
|
uint160& operator=(const basetype& b)
|
|
{
|
|
for (int i = 0; i < WIDTH; i++)
|
|
pn[i] = b.pn[i];
|
|
return *this;
|
|
}
|
|
|
|
uint160(uint64 b)
|
|
{
|
|
pn[0] = (unsigned int)b;
|
|
pn[1] = (unsigned int)(b >> 32);
|
|
for (int i = 2; i < WIDTH; i++)
|
|
pn[i] = 0;
|
|
}
|
|
|
|
uint160& operator=(uint64 b)
|
|
{
|
|
pn[0] = (unsigned int)b;
|
|
pn[1] = (unsigned int)(b >> 32);
|
|
for (int i = 2; i < WIDTH; i++)
|
|
pn[i] = 0;
|
|
return *this;
|
|
}
|
|
|
|
explicit uint160(const std::string& str)
|
|
{
|
|
SetHex(str);
|
|
}
|
|
|
|
explicit uint160(const std::vector<unsigned char>& vch)
|
|
{
|
|
if (vch.size() == sizeof(pn))
|
|
memcpy(pn, &vch[0], sizeof(pn));
|
|
else
|
|
*this = 0;
|
|
}
|
|
};
|
|
|
|
inline bool operator==(const uint160& a, uint64 b) { return (base_uint160)a == b; }
|
|
inline bool operator!=(const uint160& a, uint64 b) { return (base_uint160)a != b; }
|
|
inline const uint160 operator<<(const base_uint160& a, unsigned int shift) { return uint160(a) <<= shift; }
|
|
inline const uint160 operator>>(const base_uint160& a, unsigned int shift) { return uint160(a) >>= shift; }
|
|
inline const uint160 operator<<(const uint160& a, unsigned int shift) { return uint160(a) <<= shift; }
|
|
inline const uint160 operator>>(const uint160& a, unsigned int shift) { return uint160(a) >>= shift; }
|
|
|
|
inline const uint160 operator^(const base_uint160& a, const base_uint160& b) { return uint160(a) ^= b; }
|
|
inline const uint160 operator&(const base_uint160& a, const base_uint160& b) { return uint160(a) &= b; }
|
|
inline const uint160 operator|(const base_uint160& a, const base_uint160& b) { return uint160(a) |= b; }
|
|
inline const uint160 operator+(const base_uint160& a, const base_uint160& b) { return uint160(a) += b; }
|
|
inline const uint160 operator-(const base_uint160& a, const base_uint160& b) { return uint160(a) -= b; }
|
|
|
|
inline bool operator<(const base_uint160& a, const uint160& b) { return (base_uint160)a < (base_uint160)b; }
|
|
inline bool operator<=(const base_uint160& a, const uint160& b) { return (base_uint160)a <= (base_uint160)b; }
|
|
inline bool operator>(const base_uint160& a, const uint160& b) { return (base_uint160)a > (base_uint160)b; }
|
|
inline bool operator>=(const base_uint160& a, const uint160& b) { return (base_uint160)a >= (base_uint160)b; }
|
|
inline bool operator==(const base_uint160& a, const uint160& b) { return (base_uint160)a == (base_uint160)b; }
|
|
inline bool operator!=(const base_uint160& a, const uint160& b) { return (base_uint160)a != (base_uint160)b; }
|
|
inline const uint160 operator^(const base_uint160& a, const uint160& b) { return (base_uint160)a ^ (base_uint160)b; }
|
|
inline const uint160 operator&(const base_uint160& a, const uint160& b) { return (base_uint160)a & (base_uint160)b; }
|
|
inline const uint160 operator|(const base_uint160& a, const uint160& b) { return (base_uint160)a | (base_uint160)b; }
|
|
inline const uint160 operator+(const base_uint160& a, const uint160& b) { return (base_uint160)a + (base_uint160)b; }
|
|
inline const uint160 operator-(const base_uint160& a, const uint160& b) { return (base_uint160)a - (base_uint160)b; }
|
|
|
|
inline bool operator<(const uint160& a, const base_uint160& b) { return (base_uint160)a < (base_uint160)b; }
|
|
inline bool operator<=(const uint160& a, const base_uint160& b) { return (base_uint160)a <= (base_uint160)b; }
|
|
inline bool operator>(const uint160& a, const base_uint160& b) { return (base_uint160)a > (base_uint160)b; }
|
|
inline bool operator>=(const uint160& a, const base_uint160& b) { return (base_uint160)a >= (base_uint160)b; }
|
|
inline bool operator==(const uint160& a, const base_uint160& b) { return (base_uint160)a == (base_uint160)b; }
|
|
inline bool operator!=(const uint160& a, const base_uint160& b) { return (base_uint160)a != (base_uint160)b; }
|
|
inline const uint160 operator^(const uint160& a, const base_uint160& b) { return (base_uint160)a ^ (base_uint160)b; }
|
|
inline const uint160 operator&(const uint160& a, const base_uint160& b) { return (base_uint160)a & (base_uint160)b; }
|
|
inline const uint160 operator|(const uint160& a, const base_uint160& b) { return (base_uint160)a | (base_uint160)b; }
|
|
inline const uint160 operator+(const uint160& a, const base_uint160& b) { return (base_uint160)a + (base_uint160)b; }
|
|
inline const uint160 operator-(const uint160& a, const base_uint160& b) { return (base_uint160)a - (base_uint160)b; }
|
|
|
|
inline bool operator<(const uint160& a, const uint160& b) { return (base_uint160)a < (base_uint160)b; }
|
|
inline bool operator<=(const uint160& a, const uint160& b) { return (base_uint160)a <= (base_uint160)b; }
|
|
inline bool operator>(const uint160& a, const uint160& b) { return (base_uint160)a > (base_uint160)b; }
|
|
inline bool operator>=(const uint160& a, const uint160& b) { return (base_uint160)a >= (base_uint160)b; }
|
|
inline bool operator==(const uint160& a, const uint160& b) { return (base_uint160)a == (base_uint160)b; }
|
|
inline bool operator!=(const uint160& a, const uint160& b) { return (base_uint160)a != (base_uint160)b; }
|
|
inline const uint160 operator^(const uint160& a, const uint160& b) { return (base_uint160)a ^ (base_uint160)b; }
|
|
inline const uint160 operator&(const uint160& a, const uint160& b) { return (base_uint160)a & (base_uint160)b; }
|
|
inline const uint160 operator|(const uint160& a, const uint160& b) { return (base_uint160)a | (base_uint160)b; }
|
|
inline const uint160 operator+(const uint160& a, const uint160& b) { return (base_uint160)a + (base_uint160)b; }
|
|
inline const uint160 operator-(const uint160& a, const uint160& b) { return (base_uint160)a - (base_uint160)b; }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// uint256
|
|
//
|
|
|
|
class uint256 : public base_uint256
|
|
{
|
|
public:
|
|
typedef base_uint256 basetype;
|
|
|
|
uint256()
|
|
{
|
|
for (int i = 0; i < WIDTH; i++)
|
|
pn[i] = 0;
|
|
}
|
|
|
|
uint256(const basetype& b)
|
|
{
|
|
for (int i = 0; i < WIDTH; i++)
|
|
pn[i] = b.pn[i];
|
|
}
|
|
|
|
uint256& operator=(const basetype& b)
|
|
{
|
|
for (int i = 0; i < WIDTH; i++)
|
|
pn[i] = b.pn[i];
|
|
return *this;
|
|
}
|
|
|
|
uint256(uint64 b)
|
|
{
|
|
pn[0] = (unsigned int)b;
|
|
pn[1] = (unsigned int)(b >> 32);
|
|
for (int i = 2; i < WIDTH; i++)
|
|
pn[i] = 0;
|
|
}
|
|
|
|
uint256& operator=(uint64 b)
|
|
{
|
|
pn[0] = (unsigned int)b;
|
|
pn[1] = (unsigned int)(b >> 32);
|
|
for (int i = 2; i < WIDTH; i++)
|
|
pn[i] = 0;
|
|
return *this;
|
|
}
|
|
|
|
explicit uint256(const std::string& str)
|
|
{
|
|
SetHex(str);
|
|
}
|
|
|
|
explicit uint256(const std::vector<unsigned char>& vch)
|
|
{
|
|
if (vch.size() == sizeof(pn))
|
|
memcpy(pn, &vch[0], sizeof(pn));
|
|
else
|
|
*this = 0;
|
|
}
|
|
};
|
|
|
|
inline bool operator==(const uint256& a, uint64 b) { return (base_uint256)a == b; }
|
|
inline bool operator!=(const uint256& a, uint64 b) { return (base_uint256)a != b; }
|
|
inline const uint256 operator<<(const base_uint256& a, unsigned int shift) { return uint256(a) <<= shift; }
|
|
inline const uint256 operator>>(const base_uint256& a, unsigned int shift) { return uint256(a) >>= shift; }
|
|
inline const uint256 operator<<(const uint256& a, unsigned int shift) { return uint256(a) <<= shift; }
|
|
inline const uint256 operator>>(const uint256& a, unsigned int shift) { return uint256(a) >>= shift; }
|
|
|
|
inline const uint256 operator^(const base_uint256& a, const base_uint256& b) { return uint256(a) ^= b; }
|
|
inline const uint256 operator&(const base_uint256& a, const base_uint256& b) { return uint256(a) &= b; }
|
|
inline const uint256 operator|(const base_uint256& a, const base_uint256& b) { return uint256(a) |= b; }
|
|
inline const uint256 operator+(const base_uint256& a, const base_uint256& b) { return uint256(a) += b; }
|
|
inline const uint256 operator-(const base_uint256& a, const base_uint256& b) { return uint256(a) -= b; }
|
|
|
|
inline bool operator<(const base_uint256& a, const uint256& b) { return (base_uint256)a < (base_uint256)b; }
|
|
inline bool operator<=(const base_uint256& a, const uint256& b) { return (base_uint256)a <= (base_uint256)b; }
|
|
inline bool operator>(const base_uint256& a, const uint256& b) { return (base_uint256)a > (base_uint256)b; }
|
|
inline bool operator>=(const base_uint256& a, const uint256& b) { return (base_uint256)a >= (base_uint256)b; }
|
|
inline bool operator==(const base_uint256& a, const uint256& b) { return (base_uint256)a == (base_uint256)b; }
|
|
inline bool operator!=(const base_uint256& a, const uint256& b) { return (base_uint256)a != (base_uint256)b; }
|
|
inline const uint256 operator^(const base_uint256& a, const uint256& b) { return (base_uint256)a ^ (base_uint256)b; }
|
|
inline const uint256 operator&(const base_uint256& a, const uint256& b) { return (base_uint256)a & (base_uint256)b; }
|
|
inline const uint256 operator|(const base_uint256& a, const uint256& b) { return (base_uint256)a | (base_uint256)b; }
|
|
inline const uint256 operator+(const base_uint256& a, const uint256& b) { return (base_uint256)a + (base_uint256)b; }
|
|
inline const uint256 operator-(const base_uint256& a, const uint256& b) { return (base_uint256)a - (base_uint256)b; }
|
|
|
|
inline bool operator<(const uint256& a, const base_uint256& b) { return (base_uint256)a < (base_uint256)b; }
|
|
inline bool operator<=(const uint256& a, const base_uint256& b) { return (base_uint256)a <= (base_uint256)b; }
|
|
inline bool operator>(const uint256& a, const base_uint256& b) { return (base_uint256)a > (base_uint256)b; }
|
|
inline bool operator>=(const uint256& a, const base_uint256& b) { return (base_uint256)a >= (base_uint256)b; }
|
|
inline bool operator==(const uint256& a, const base_uint256& b) { return (base_uint256)a == (base_uint256)b; }
|
|
inline bool operator!=(const uint256& a, const base_uint256& b) { return (base_uint256)a != (base_uint256)b; }
|
|
inline const uint256 operator^(const uint256& a, const base_uint256& b) { return (base_uint256)a ^ (base_uint256)b; }
|
|
inline const uint256 operator&(const uint256& a, const base_uint256& b) { return (base_uint256)a & (base_uint256)b; }
|
|
inline const uint256 operator|(const uint256& a, const base_uint256& b) { return (base_uint256)a | (base_uint256)b; }
|
|
inline const uint256 operator+(const uint256& a, const base_uint256& b) { return (base_uint256)a + (base_uint256)b; }
|
|
inline const uint256 operator-(const uint256& a, const base_uint256& b) { return (base_uint256)a - (base_uint256)b; }
|
|
|
|
inline bool operator<(const uint256& a, const uint256& b) { return (base_uint256)a < (base_uint256)b; }
|
|
inline bool operator<=(const uint256& a, const uint256& b) { return (base_uint256)a <= (base_uint256)b; }
|
|
inline bool operator>(const uint256& a, const uint256& b) { return (base_uint256)a > (base_uint256)b; }
|
|
inline bool operator>=(const uint256& a, const uint256& b) { return (base_uint256)a >= (base_uint256)b; }
|
|
inline bool operator==(const uint256& a, const uint256& b) { return (base_uint256)a == (base_uint256)b; }
|
|
inline bool operator!=(const uint256& a, const uint256& b) { return (base_uint256)a != (base_uint256)b; }
|
|
inline const uint256 operator^(const uint256& a, const uint256& b) { return (base_uint256)a ^ (base_uint256)b; }
|
|
inline const uint256 operator&(const uint256& a, const uint256& b) { return (base_uint256)a & (base_uint256)b; }
|
|
inline const uint256 operator|(const uint256& a, const uint256& b) { return (base_uint256)a | (base_uint256)b; }
|
|
inline const uint256 operator+(const uint256& a, const uint256& b) { return (base_uint256)a + (base_uint256)b; }
|
|
inline const uint256 operator-(const uint256& a, const uint256& b) { return (base_uint256)a - (base_uint256)b; }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#ifdef TEST_UINT256
|
|
|
|
inline int Testuint256AdHoc(std::vector<std::string> vArg)
|
|
{
|
|
uint256 g(0);
|
|
|
|
|
|
printf("%s\n", g.ToString().c_str());
|
|
g--; printf("g--\n");
|
|
printf("%s\n", g.ToString().c_str());
|
|
g--; printf("g--\n");
|
|
printf("%s\n", g.ToString().c_str());
|
|
g++; printf("g++\n");
|
|
printf("%s\n", g.ToString().c_str());
|
|
g++; printf("g++\n");
|
|
printf("%s\n", g.ToString().c_str());
|
|
g++; printf("g++\n");
|
|
printf("%s\n", g.ToString().c_str());
|
|
g++; printf("g++\n");
|
|
printf("%s\n", g.ToString().c_str());
|
|
|
|
|
|
|
|
uint256 a(7);
|
|
printf("a=7\n");
|
|
printf("%s\n", a.ToString().c_str());
|
|
|
|
uint256 b;
|
|
printf("b undefined\n");
|
|
printf("%s\n", b.ToString().c_str());
|
|
int c = 3;
|
|
|
|
a = c;
|
|
a.pn[3] = 15;
|
|
printf("%s\n", a.ToString().c_str());
|
|
uint256 k(c);
|
|
|
|
a = 5;
|
|
a.pn[3] = 15;
|
|
printf("%s\n", a.ToString().c_str());
|
|
b = 1;
|
|
b <<= 52;
|
|
|
|
a |= b;
|
|
|
|
a ^= 0x500;
|
|
|
|
printf("a %s\n", a.ToString().c_str());
|
|
|
|
a = a | b | (uint256)0x1000;
|
|
|
|
|
|
printf("a %s\n", a.ToString().c_str());
|
|
printf("b %s\n", b.ToString().c_str());
|
|
|
|
a = 0xfffffffe;
|
|
a.pn[4] = 9;
|
|
|
|
printf("%s\n", a.ToString().c_str());
|
|
a++;
|
|
printf("%s\n", a.ToString().c_str());
|
|
a++;
|
|
printf("%s\n", a.ToString().c_str());
|
|
a++;
|
|
printf("%s\n", a.ToString().c_str());
|
|
a++;
|
|
printf("%s\n", a.ToString().c_str());
|
|
|
|
a--;
|
|
printf("%s\n", a.ToString().c_str());
|
|
a--;
|
|
printf("%s\n", a.ToString().c_str());
|
|
a--;
|
|
printf("%s\n", a.ToString().c_str());
|
|
uint256 d = a--;
|
|
printf("%s\n", d.ToString().c_str());
|
|
printf("%s\n", a.ToString().c_str());
|
|
a--;
|
|
printf("%s\n", a.ToString().c_str());
|
|
a--;
|
|
printf("%s\n", a.ToString().c_str());
|
|
|
|
d = a;
|
|
|
|
printf("%s\n", d.ToString().c_str());
|
|
for (int i = uint256::WIDTH-1; i >= 0; i--) printf("%08x", d.pn[i]); printf("\n");
|
|
|
|
uint256 neg = d;
|
|
neg = ~neg;
|
|
printf("%s\n", neg.ToString().c_str());
|
|
|
|
|
|
uint256 e = uint256("0xABCDEF123abcdef12345678909832180000011111111");
|
|
printf("\n");
|
|
printf("%s\n", e.ToString().c_str());
|
|
|
|
|
|
printf("\n");
|
|
uint256 x1 = uint256("0xABCDEF123abcdef12345678909832180000011111111");
|
|
uint256 x2;
|
|
printf("%s\n", x1.ToString().c_str());
|
|
for (int i = 0; i < 270; i += 4)
|
|
{
|
|
x2 = x1 << i;
|
|
printf("%s\n", x2.ToString().c_str());
|
|
}
|
|
|
|
printf("\n");
|
|
printf("%s\n", x1.ToString().c_str());
|
|
for (int i = 0; i < 270; i += 4)
|
|
{
|
|
x2 = x1;
|
|
x2 >>= i;
|
|
printf("%s\n", x2.ToString().c_str());
|
|
}
|
|
|
|
|
|
for (int i = 0; i < 100; i++)
|
|
{
|
|
uint256 k = (~uint256(0) >> i);
|
|
printf("%s\n", k.ToString().c_str());
|
|
}
|
|
|
|
for (int i = 0; i < 100; i++)
|
|
{
|
|
uint256 k = (~uint256(0) << i);
|
|
printf("%s\n", k.ToString().c_str());
|
|
}
|
|
|
|
return (0);
|
|
}
|
|
|
|
#endif
|
|
|
|
#endif
|