Line data    Source code

       1             : // Copyright (c) 2009-2010 Satoshi Nakamoto
       2             : // Copyright (c) 2009-2019 The Bitcoin Core developers
       3             : // Distributed under the MIT software license, see the accompanying
       4             : // file COPYING or http://www.opensource.org/licenses/mit-license.php.
       5             : 
       6             : #include <uint256.h>
       7             : 
       8             : #include <util/strencodings.h>
       9             : 
      10             : #include <string.h>
      11             : 
      12             : template <unsigned int BITS>
      13     2301877 : base_blob<BITS>::base_blob(const std::vector<unsigned char>& vch)
      14           0 : {
      15     2301877 :     assert(vch.size() == sizeof(m_data));
      16     2301877 :     memcpy(m_data, vch.data(), sizeof(m_data));
      17     2301877 : }
      18             : 
      19             : template <unsigned int BITS>
      20     6363816 : std::string base_blob<BITS>::GetHex() const
      21             : {
      22     6363816 :     uint8_t m_data_rev[WIDTH];
      23   209984684 :     for (int i = 0; i < WIDTH; ++i) {
      24   203620891 :         m_data_rev[i] = m_data[WIDTH - 1 - i];
      25             :     }
      26     6363813 :     return HexStr(m_data_rev);
      27     6363813 : }
      28             : 
      29             : template <unsigned int BITS>
      30       77907 : void base_blob<BITS>::SetHex(const char* psz)
      31             : {
      32       77907 :     memset(m_data, 0, sizeof(m_data));
      33             : 
      34             :     // skip leading spaces
      35       77916 :     while (IsSpace(*psz))
      36           9 :         psz++;
      37             : 
      38             :     // skip 0x
      39       77907 :     if (psz[0] == '0' && ToLower(psz[1]) == 'x')
      40       44815 :         psz += 2;
      41             : 
      42             :     // hex string to uint
      43             :     size_t digits = 0;
      44     4856303 :     while (::HexDigit(psz[digits]) != -1)
      45     4778396 :         digits++;
      46             :     unsigned char* p1 = (unsigned char*)m_data;
      47       77907 :     unsigned char* pend = p1 + WIDTH;
      48     2467096 :     while (digits > 0 && p1 < pend) {
      49     2389189 :         *p1 = ::HexDigit(psz[--digits]);
      50     2389189 :         if (digits > 0) {
      51     2389183 :             *p1 |= ((unsigned char)::HexDigit(psz[--digits]) << 4);
      52     2389183 :             p1++;
      53     2389183 :         }
      54             :     }
      55       77907 : }
      56             : 
      57             : template <unsigned int BITS>
      58       20706 : void base_blob<BITS>::SetHex(const std::string& str)
      59             : {
      60       20706 :     SetHex(str.c_str());
      61       20706 : }
      62             : 
      63             : template <unsigned int BITS>
      64     6144703 : std::string base_blob<BITS>::ToString() const
      65             : {
      66     6144703 :     return (GetHex());
      67             : }
      68             : 
      69             : // Explicit instantiations for base_blob<160>
      70             : template base_blob<160>::base_blob(const std::vector<unsigned char>&);
      71             : template std::string base_blob<160>::GetHex() const;
      72             : template std::string base_blob<160>::ToString() const;
      73             : template void base_blob<160>::SetHex(const char*);
      74             : template void base_blob<160>::SetHex(const std::string&);
      75             : 
      76             : // Explicit instantiations for base_blob<256>
      77             : template base_blob<256>::base_blob(const std::vector<unsigned char>&);
      78             : template std::string base_blob<256>::GetHex() const;
      79             : template std::string base_blob<256>::ToString() const;
      80             : template void base_blob<256>::SetHex(const char*);
      81             : template void base_blob<256>::SetHex(const std::string&);
      82             : 
      83        1349 : uint256& UINT256_ONE() {
      84        1349 :     static uint256* one = new uint256(uint256S("0000000000000000000000000000000000000000000000000000000000000001"));
      85        1349 :     return *one;
      86           0 : }