Browse Source
Split up util.cpp/h into: - string utilities (hex, base32, base64): no internal dependencies, no dependency on boost (apart from foreach) - money utilities (parsesmoney, formatmoney) - time utilities (gettime*, sleep, format date): - and the rest (logging, argument parsing, config file parsing) The latter is basically the environment and OS handling, and is stripped of all utility functions, so we may want to rename it to something else than util.cpp/h for clarity (Matt suggested osinterface). Breaks dependency of sha256.cpp on all the things pulled in by util.pull/145/head
Wladimir J. van der Laan
10 years ago
57 changed files with 875 additions and 734 deletions
@ -0,0 +1,75 @@ |
|||
#include "utilmoneystr.h" |
|||
|
|||
#include "core.h" |
|||
#include "tinyformat.h" |
|||
|
|||
using namespace std; |
|||
|
|||
string FormatMoney(int64_t n, bool fPlus) |
|||
{ |
|||
// Note: not using straight sprintf here because we do NOT want
|
|||
// localized number formatting.
|
|||
int64_t n_abs = (n > 0 ? n : -n); |
|||
int64_t quotient = n_abs/COIN; |
|||
int64_t remainder = n_abs%COIN; |
|||
string str = strprintf("%d.%08d", quotient, remainder); |
|||
|
|||
// Right-trim excess zeros before the decimal point:
|
|||
int nTrim = 0; |
|||
for (int i = str.size()-1; (str[i] == '0' && isdigit(str[i-2])); --i) |
|||
++nTrim; |
|||
if (nTrim) |
|||
str.erase(str.size()-nTrim, nTrim); |
|||
|
|||
if (n < 0) |
|||
str.insert((unsigned int)0, 1, '-'); |
|||
else if (fPlus && n > 0) |
|||
str.insert((unsigned int)0, 1, '+'); |
|||
return str; |
|||
} |
|||
|
|||
|
|||
bool ParseMoney(const string& str, int64_t& nRet) |
|||
{ |
|||
return ParseMoney(str.c_str(), nRet); |
|||
} |
|||
|
|||
bool ParseMoney(const char* pszIn, int64_t& nRet) |
|||
{ |
|||
string strWhole; |
|||
int64_t nUnits = 0; |
|||
const char* p = pszIn; |
|||
while (isspace(*p)) |
|||
p++; |
|||
for (; *p; p++) |
|||
{ |
|||
if (*p == '.') |
|||
{ |
|||
p++; |
|||
int64_t nMult = CENT*10; |
|||
while (isdigit(*p) && (nMult > 0)) |
|||
{ |
|||
nUnits += nMult * (*p++ - '0'); |
|||
nMult /= 10; |
|||
} |
|||
break; |
|||
} |
|||
if (isspace(*p)) |
|||
break; |
|||
if (!isdigit(*p)) |
|||
return false; |
|||
strWhole.insert(strWhole.end(), *p); |
|||
} |
|||
for (; *p; p++) |
|||
if (!isspace(*p)) |
|||
return false; |
|||
if (strWhole.size() > 10) // guard against 63 bit overflow
|
|||
return false; |
|||
if (nUnits < 0 || nUnits > COIN) |
|||
return false; |
|||
int64_t nWhole = atoi64(strWhole); |
|||
int64_t nValue = nWhole*COIN + nUnits; |
|||
|
|||
nRet = nValue; |
|||
return true; |
|||
} |
|||
@ -0,0 +1,19 @@ |
|||
// Copyright (c) 2009-2010 Satoshi Nakamoto
|
|||
// Copyright (c) 2009-2014 The Bitcoin developers
|
|||
// Distributed under the MIT/X11 software license, see the accompanying
|
|||
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
|||
|
|||
/**
|
|||
* Money parsing/formatting utilities. |
|||
*/ |
|||
#ifndef BITCOIN_UTILMONEYSTR_H |
|||
#define BITCOIN_UTILMONEYSTR_H |
|||
|
|||
#include <stdint.h> |
|||
#include <string> |
|||
|
|||
std::string FormatMoney(int64_t n, bool fPlus=false); |
|||
bool ParseMoney(const std::string& str, int64_t& nRet); |
|||
bool ParseMoney(const char* pszIn, int64_t& nRet); |
|||
|
|||
#endif // BITCOIN_UTILMONEYSTR_H
|
|||
@ -0,0 +1,496 @@ |
|||
// Copyright (c) 2009-2010 Satoshi Nakamoto
|
|||
// Copyright (c) 2009-2014 The Bitcoin developers
|
|||
// Distributed under the MIT/X11 software license, see the accompanying
|
|||
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
|||
|
|||
#include "utilstrencodings.h" |
|||
|
|||
#include "tinyformat.h" |
|||
|
|||
#include <boost/foreach.hpp> |
|||
#include <errno.h> |
|||
#include <limits> |
|||
|
|||
using namespace std; |
|||
|
|||
// safeChars chosen to allow simple messages/URLs/email addresses, but avoid anything
|
|||
// even possibly remotely dangerous like & or >
|
|||
static string safeChars("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ01234567890 .,;_/:?@"); |
|||
string SanitizeString(const string& str) |
|||
{ |
|||
string strResult; |
|||
for (std::string::size_type i = 0; i < str.size(); i++) |
|||
{ |
|||
if (safeChars.find(str[i]) != std::string::npos) |
|||
strResult.push_back(str[i]); |
|||
} |
|||
return strResult; |
|||
} |
|||
|
|||
const signed char p_util_hexdigit[256] = |
|||
{ -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, |
|||
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, |
|||
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, |
|||
0,1,2,3,4,5,6,7,8,9,-1,-1,-1,-1,-1,-1, |
|||
-1,0xa,0xb,0xc,0xd,0xe,0xf,-1,-1,-1,-1,-1,-1,-1,-1,-1, |
|||
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, |
|||
-1,0xa,0xb,0xc,0xd,0xe,0xf,-1,-1,-1,-1,-1,-1,-1,-1,-1, |
|||
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, |
|||
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, |
|||
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, |
|||
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, |
|||
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, |
|||
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, |
|||
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, |
|||
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, |
|||
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, }; |
|||
|
|||
signed char HexDigit(char c) |
|||
{ |
|||
return p_util_hexdigit[(unsigned char)c]; |
|||
} |
|||
|
|||
bool IsHex(const string& str) |
|||
{ |
|||
BOOST_FOREACH(char c, str) |
|||
{ |
|||
if (HexDigit(c) < 0) |
|||
return false; |
|||
} |
|||
return (str.size() > 0) && (str.size()%2 == 0); |
|||
} |
|||
|
|||
vector<unsigned char> ParseHex(const char* psz) |
|||
{ |
|||
// convert hex dump to vector
|
|||
vector<unsigned char> vch; |
|||
while (true) |
|||
{ |
|||
while (isspace(*psz)) |
|||
psz++; |
|||
signed char c = HexDigit(*psz++); |
|||
if (c == (signed char)-1) |
|||
break; |
|||
unsigned char n = (c << 4); |
|||
c = HexDigit(*psz++); |
|||
if (c == (signed char)-1) |
|||
break; |
|||
n |= c; |
|||
vch.push_back(n); |
|||
} |
|||
return vch; |
|||
} |
|||
|
|||
vector<unsigned char> ParseHex(const string& str) |
|||
{ |
|||
return ParseHex(str.c_str()); |
|||
} |
|||
|
|||
string EncodeBase64(const unsigned char* pch, size_t len) |
|||
{ |
|||
static const char *pbase64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; |
|||
|
|||
string strRet=""; |
|||
strRet.reserve((len+2)/3*4); |
|||
|
|||
int mode=0, left=0; |
|||
const unsigned char *pchEnd = pch+len; |
|||
|
|||
while (pch<pchEnd) |
|||
{ |
|||
int enc = *(pch++); |
|||
switch (mode) |
|||
{ |
|||
case 0: // we have no bits
|
|||
strRet += pbase64[enc >> 2]; |
|||
left = (enc & 3) << 4; |
|||
mode = 1; |
|||
break; |
|||
|
|||
case 1: // we have two bits
|
|||
strRet += pbase64[left | (enc >> 4)]; |
|||
left = (enc & 15) << 2; |
|||
mode = 2; |
|||
break; |
|||
|
|||
case 2: // we have four bits
|
|||
strRet += pbase64[left | (enc >> 6)]; |
|||
strRet += pbase64[enc & 63]; |
|||
mode = 0; |
|||
break; |
|||
} |
|||
} |
|||
|
|||
if (mode) |
|||
{ |
|||
strRet += pbase64[left]; |
|||
strRet += '='; |
|||
if (mode == 1) |
|||
strRet += '='; |
|||
} |
|||
|
|||
return strRet; |
|||
} |
|||
|
|||
string EncodeBase64(const string& str) |
|||
{ |
|||
return EncodeBase64((const unsigned char*)str.c_str(), str.size()); |
|||
} |
|||
|
|||
vector<unsigned char> DecodeBase64(const char* p, bool* pfInvalid) |
|||
{ |
|||
static const int decode64_table[256] = |
|||
{ |
|||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, |
|||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, |
|||
-1, -1, -1, 62, -1, -1, -1, 63, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, -1, -1, |
|||
-1, -1, -1, -1, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, |
|||
15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1, -1, -1, 26, 27, 28, |
|||
29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, |
|||
49, 50, 51, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, |
|||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, |
|||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, |
|||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, |
|||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, |
|||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, |
|||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 |
|||
}; |
|||
|
|||
if (pfInvalid) |
|||
*pfInvalid = false; |
|||
|
|||
vector<unsigned char> vchRet; |
|||
vchRet.reserve(strlen(p)*3/4); |
|||
|
|||
int mode = 0; |
|||
int left = 0; |
|||
|
|||
while (1) |
|||
{ |
|||
int dec = decode64_table[(unsigned char)*p]; |
|||
if (dec == -1) break; |
|||
p++; |
|||
switch (mode) |
|||
{ |
|||
case 0: // we have no bits and get 6
|
|||
left = dec; |
|||
mode = 1; |
|||
break; |
|||
|
|||
case 1: // we have 6 bits and keep 4
|
|||
vchRet.push_back((left<<2) | (dec>>4)); |
|||
left = dec & 15; |
|||
mode = 2; |
|||
break; |
|||
|
|||
case 2: // we have 4 bits and get 6, we keep 2
|
|||
vchRet.push_back((left<<4) | (dec>>2)); |
|||
left = dec & 3; |
|||
mode = 3; |
|||
break; |
|||
|
|||
case 3: // we have 2 bits and get 6
|
|||
vchRet.push_back((left<<6) | dec); |
|||
mode = 0; |
|||
break; |
|||
} |
|||
} |
|||
|
|||
if (pfInvalid) |
|||
switch (mode) |
|||
{ |
|||
case 0: // 4n base64 characters processed: ok
|
|||
break; |
|||
|
|||
case 1: // 4n+1 base64 character processed: impossible
|
|||
*pfInvalid = true; |
|||
break; |
|||
|
|||
case 2: // 4n+2 base64 characters processed: require '=='
|
|||
if (left || p[0] != '=' || p[1] != '=' || decode64_table[(unsigned char)p[2]] != -1) |
|||
*pfInvalid = true; |
|||
break; |
|||
|
|||
case 3: // 4n+3 base64 characters processed: require '='
|
|||
if (left || p[0] != '=' || decode64_table[(unsigned char)p[1]] != -1) |
|||
*pfInvalid = true; |
|||
break; |
|||
} |
|||
|
|||
return vchRet; |
|||
} |
|||
|
|||
string DecodeBase64(const string& str) |
|||
{ |
|||
vector<unsigned char> vchRet = DecodeBase64(str.c_str()); |
|||
return string((const char*)&vchRet[0], vchRet.size()); |
|||
} |
|||
|
|||
string EncodeBase32(const unsigned char* pch, size_t len) |
|||
{ |
|||
static const char *pbase32 = "abcdefghijklmnopqrstuvwxyz234567"; |
|||
|
|||
string strRet=""; |
|||
strRet.reserve((len+4)/5*8); |
|||
|
|||
int mode=0, left=0; |
|||
const unsigned char *pchEnd = pch+len; |
|||
|
|||
while (pch<pchEnd) |
|||
{ |
|||
int enc = *(pch++); |
|||
switch (mode) |
|||
{ |
|||
case 0: // we have no bits
|
|||
strRet += pbase32[enc >> 3]; |
|||
left = (enc & 7) << 2; |
|||
mode = 1; |
|||
break; |
|||
|
|||
case 1: // we have three bits
|
|||
strRet += pbase32[left | (enc >> 6)]; |
|||
strRet += pbase32[(enc >> 1) & 31]; |
|||
left = (enc & 1) << 4; |
|||
mode = 2; |
|||
break; |
|||
|
|||
case 2: // we have one bit
|
|||
strRet += pbase32[left | (enc >> 4)]; |
|||
left = (enc & 15) << 1; |
|||
mode = 3; |
|||
break; |
|||
|
|||
case 3: // we have four bits
|
|||
strRet += pbase32[left | (enc >> 7)]; |
|||
strRet += pbase32[(enc >> 2) & 31]; |
|||
left = (enc & 3) << 3; |
|||
mode = 4; |
|||
break; |
|||
|
|||
case 4: // we have two bits
|
|||
strRet += pbase32[left | (enc >> 5)]; |
|||
strRet += pbase32[enc & 31]; |
|||
mode = 0; |
|||
} |
|||
} |
|||
|
|||
static const int nPadding[5] = {0, 6, 4, 3, 1}; |
|||
if (mode) |
|||
{ |
|||
strRet += pbase32[left]; |
|||
for (int n=0; n<nPadding[mode]; n++) |
|||
strRet += '='; |
|||
} |
|||
|
|||
return strRet; |
|||
} |
|||
|
|||
string EncodeBase32(const string& str) |
|||
{ |
|||
return EncodeBase32((const unsigned char*)str.c_str(), str.size()); |
|||
} |
|||
|
|||
vector<unsigned char> DecodeBase32(const char* p, bool* pfInvalid) |
|||
{ |
|||
static const int decode32_table[256] = |
|||
{ |
|||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, |
|||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, |
|||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 26, 27, 28, 29, 30, 31, -1, -1, -1, -1, |
|||
-1, -1, -1, -1, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, |
|||
15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1, -1, -1, 0, 1, 2, |
|||
3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, |
|||
23, 24, 25, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, |
|||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, |
|||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, |
|||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, |
|||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, |
|||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, |
|||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 |
|||
}; |
|||
|
|||
if (pfInvalid) |
|||
*pfInvalid = false; |
|||
|
|||
vector<unsigned char> vchRet; |
|||
vchRet.reserve((strlen(p))*5/8); |
|||
|
|||
int mode = 0; |
|||
int left = 0; |
|||
|
|||
while (1) |
|||
{ |
|||
int dec = decode32_table[(unsigned char)*p]; |
|||
if (dec == -1) break; |
|||
p++; |
|||
switch (mode) |
|||
{ |
|||
case 0: // we have no bits and get 5
|
|||
left = dec; |
|||
mode = 1; |
|||
break; |
|||
|
|||
case 1: // we have 5 bits and keep 2
|
|||
vchRet.push_back((left<<3) | (dec>>2)); |
|||
left = dec & 3; |
|||
mode = 2; |
|||
break; |
|||
|
|||
case 2: // we have 2 bits and keep 7
|
|||
left = left << 5 | dec; |
|||
mode = 3; |
|||
break; |
|||
|
|||
case 3: // we have 7 bits and keep 4
|
|||
vchRet.push_back((left<<1) | (dec>>4)); |
|||
left = dec & 15; |
|||
mode = 4; |
|||
break; |
|||
|
|||
case 4: // we have 4 bits, and keep 1
|
|||
vchRet.push_back((left<<4) | (dec>>1)); |
|||
left = dec & 1; |
|||
mode = 5; |
|||
break; |
|||
|
|||
case 5: // we have 1 bit, and keep 6
|
|||
left = left << 5 | dec; |
|||
mode = 6; |
|||
break; |
|||
|
|||
case 6: // we have 6 bits, and keep 3
|
|||
vchRet.push_back((left<<2) | (dec>>3)); |
|||
left = dec & 7; |
|||
mode = 7; |
|||
break; |
|||
|
|||
case 7: // we have 3 bits, and keep 0
|
|||
vchRet.push_back((left<<5) | dec); |
|||
mode = 0; |
|||
break; |
|||
} |
|||
} |
|||
|
|||
if (pfInvalid) |
|||
switch (mode) |
|||
{ |
|||
case 0: // 8n base32 characters processed: ok
|
|||
break; |
|||
|
|||
case 1: // 8n+1 base32 characters processed: impossible
|
|||
case 3: // +3
|
|||
case 6: // +6
|
|||
*pfInvalid = true; |
|||
break; |
|||
|
|||
case 2: // 8n+2 base32 characters processed: require '======'
|
|||
if (left || p[0] != '=' || p[1] != '=' || p[2] != '=' || p[3] != '=' || p[4] != '=' || p[5] != '=' || decode32_table[(unsigned char)p[6]] != -1) |
|||
*pfInvalid = true; |
|||
break; |
|||
|
|||
case 4: // 8n+4 base32 characters processed: require '===='
|
|||
if (left || p[0] != '=' || p[1] != '=' || p[2] != '=' || p[3] != '=' || decode32_table[(unsigned char)p[4]] != -1) |
|||
*pfInvalid = true; |
|||
break; |
|||
|
|||
case 5: // 8n+5 base32 characters processed: require '==='
|
|||
if (left || p[0] != '=' || p[1] != '=' || p[2] != '=' || decode32_table[(unsigned char)p[3]] != -1) |
|||
*pfInvalid = true; |
|||
break; |
|||
|
|||
case 7: // 8n+7 base32 characters processed: require '='
|
|||
if (left || p[0] != '=' || decode32_table[(unsigned char)p[1]] != -1) |
|||
*pfInvalid = true; |
|||
break; |
|||
} |
|||
|
|||
return vchRet; |
|||
} |
|||
|
|||
string DecodeBase32(const string& str) |
|||
{ |
|||
vector<unsigned char> vchRet = DecodeBase32(str.c_str()); |
|||
return string((const char*)&vchRet[0], vchRet.size()); |
|||
} |
|||
|
|||
bool ParseInt32(const std::string& str, int32_t *out) |
|||
{ |
|||
char *endp = NULL; |
|||
errno = 0; // strtol will not set errno if valid
|
|||
long int n = strtol(str.c_str(), &endp, 10); |
|||
if(out) *out = (int)n; |
|||
// Note that strtol returns a *long int*, so even if strtol doesn't report a over/underflow
|
|||
// we still have to check that the returned value is within the range of an *int32_t*. On 64-bit
|
|||
// platforms the size of these types may be different.
|
|||
return endp && *endp == 0 && !errno && |
|||
n >= std::numeric_limits<int32_t>::min() && |
|||
n <= std::numeric_limits<int32_t>::max(); |
|||
} |
|||
|
|||
std::string FormatParagraph(const std::string in, size_t width, size_t indent) |
|||
{ |
|||
std::stringstream out; |
|||
size_t col = 0; |
|||
size_t ptr = 0; |
|||
while(ptr < in.size()) |
|||
{ |
|||
// Find beginning of next word
|
|||
ptr = in.find_first_not_of(' ', ptr); |
|||
if (ptr == std::string::npos) |
|||
break; |
|||
// Find end of next word
|
|||
size_t endword = in.find_first_of(' ', ptr); |
|||
if (endword == std::string::npos) |
|||
endword = in.size(); |
|||
// Add newline and indentation if this wraps over the allowed width
|
|||
if (col > 0) |
|||
{ |
|||
if ((col + endword - ptr) > width) |
|||
{ |
|||
out << '\n'; |
|||
for(size_t i=0; i<indent; ++i) |
|||
out << ' '; |
|||
col = 0; |
|||
} else |
|||
out << ' '; |
|||
} |
|||
// Append word
|
|||
out << in.substr(ptr, endword - ptr); |
|||
col += endword - ptr; |
|||
ptr = endword; |
|||
} |
|||
return out.str(); |
|||
} |
|||
|
|||
std::string i64tostr(int64_t n) |
|||
{ |
|||
return strprintf("%d", n); |
|||
} |
|||
|
|||
std::string itostr(int n) |
|||
{ |
|||
return strprintf("%d", n); |
|||
} |
|||
|
|||
int64_t atoi64(const char* psz) |
|||
{ |
|||
#ifdef _MSC_VER |
|||
return _atoi64(psz); |
|||
#else |
|||
return strtoll(psz, NULL, 10); |
|||
#endif |
|||
} |
|||
|
|||
int64_t atoi64(const std::string& str) |
|||
{ |
|||
#ifdef _MSC_VER |
|||
return _atoi64(str.c_str()); |
|||
#else |
|||
return strtoll(str.c_str(), NULL, 10); |
|||
#endif |
|||
} |
|||
|
|||
int atoi(const std::string& str) |
|||
{ |
|||
return atoi(str.c_str()); |
|||
} |
|||
@ -0,0 +1,97 @@ |
|||
// Copyright (c) 2009-2010 Satoshi Nakamoto
|
|||
// Copyright (c) 2009-2014 The Bitcoin developers
|
|||
// Distributed under the MIT/X11 software license, see the accompanying
|
|||
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
|||
|
|||
/**
|
|||
* Utilities for converting data from/to strings. |
|||
*/ |
|||
#ifndef BITCOIN_UTILSTRENCODINGS_H |
|||
#define BITCOIN_UTILSTRENCODINGS_H |
|||
|
|||
#include <stdint.h> |
|||
#include <string> |
|||
#include <vector> |
|||
|
|||
#define BEGIN(a) ((char*)&(a)) |
|||
#define END(a) ((char*)&((&(a))[1])) |
|||
#define UBEGIN(a) ((unsigned char*)&(a)) |
|||
#define UEND(a) ((unsigned char*)&((&(a))[1])) |
|||
#define ARRAYLEN(array) (sizeof(array)/sizeof((array)[0])) |
|||
|
|||
// This is needed because the foreach macro can't get over the comma in pair<t1, t2>
|
|||
#define PAIRTYPE(t1, t2) std::pair<t1, t2> |
|||
|
|||
std::string SanitizeString(const std::string& str); |
|||
std::vector<unsigned char> ParseHex(const char* psz); |
|||
std::vector<unsigned char> ParseHex(const std::string& str); |
|||
signed char HexDigit(char c); |
|||
bool IsHex(const std::string& str); |
|||
std::vector<unsigned char> DecodeBase64(const char* p, bool* pfInvalid = NULL); |
|||
std::string DecodeBase64(const std::string& str); |
|||
std::string EncodeBase64(const unsigned char* pch, size_t len); |
|||
std::string EncodeBase64(const std::string& str); |
|||
std::vector<unsigned char> DecodeBase32(const char* p, bool* pfInvalid = NULL); |
|||
std::string DecodeBase32(const std::string& str); |
|||
std::string EncodeBase32(const unsigned char* pch, size_t len); |
|||
std::string EncodeBase32(const std::string& str); |
|||
|
|||
std::string i64tostr(int64_t n); |
|||
std::string itostr(int n); |
|||
int64_t atoi64(const char* psz); |
|||
int64_t atoi64(const std::string& str); |
|||
int atoi(const std::string& str); |
|||
|
|||
/**
|
|||
* Convert string to signed 32-bit integer with strict parse error feedback. |
|||
* @returns true if the entire string could be parsed as valid integer, |
|||
* false if not the entire string could be parsed or when overflow or underflow occured. |
|||
*/ |
|||
bool ParseInt32(const std::string& str, int32_t *out); |
|||
|
|||
template<typename T> |
|||
std::string HexStr(const T itbegin, const T itend, bool fSpaces=false) |
|||
{ |
|||
std::string rv; |
|||
static const char hexmap[16] = { '0', '1', '2', '3', '4', '5', '6', '7', |
|||
'8', '9', 'a', 'b', 'c', 'd', 'e', 'f' }; |
|||
rv.reserve((itend-itbegin)*3); |
|||
for(T it = itbegin; it < itend; ++it) |
|||
{ |
|||
unsigned char val = (unsigned char)(*it); |
|||
if(fSpaces && it != itbegin) |
|||
rv.push_back(' '); |
|||
rv.push_back(hexmap[val>>4]); |
|||
rv.push_back(hexmap[val&15]); |
|||
} |
|||
|
|||
return rv; |
|||
} |
|||
|
|||
template<typename T> |
|||
inline std::string HexStr(const T& vch, bool fSpaces=false) |
|||
{ |
|||
return HexStr(vch.begin(), vch.end(), fSpaces); |
|||
} |
|||
|
|||
/** Format a paragraph of text to a fixed width, adding spaces for
|
|||
* indentation to any added line. |
|||
*/ |
|||
std::string FormatParagraph(const std::string in, size_t width=79, size_t indent=0); |
|||
|
|||
/**
|
|||
* Timing-attack-resistant comparison. |
|||
* Takes time proportional to length |
|||
* of first argument. |
|||
*/ |
|||
template <typename T> |
|||
bool TimingResistantEqual(const T& a, const T& b) |
|||
{ |
|||
if (b.size() == 0) return a.size() == 0; |
|||
size_t accumulator = a.size() ^ b.size(); |
|||
for (size_t i = 0; i < a.size(); i++) |
|||
accumulator |= a[i] ^ b[i%b.size()]; |
|||
return accumulator == 0; |
|||
} |
|||
|
|||
#endif // BITCOIN_UTILSTRENCODINGS_H
|
|||
@ -0,0 +1,66 @@ |
|||
// Copyright (c) 2009-2010 Satoshi Nakamoto
|
|||
// Copyright (c) 2009-2014 The Bitcoin developers
|
|||
// Distributed under the MIT/X11 software license, see the accompanying
|
|||
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
|||
|
|||
#if defined(HAVE_CONFIG_H) |
|||
#include "config/bitcoin-config.h" |
|||
#endif |
|||
|
|||
#include "utiltime.h" |
|||
|
|||
#include <boost/date_time/posix_time/posix_time.hpp> |
|||
#include <boost/thread.hpp> |
|||
|
|||
using namespace std; |
|||
|
|||
static int64_t nMockTime = 0; // For unit testing
|
|||
|
|||
int64_t GetTime() |
|||
{ |
|||
if (nMockTime) return nMockTime; |
|||
|
|||
return time(NULL); |
|||
} |
|||
|
|||
void SetMockTime(int64_t nMockTimeIn) |
|||
{ |
|||
nMockTime = nMockTimeIn; |
|||
} |
|||
|
|||
int64_t GetTimeMillis() |
|||
{ |
|||
return (boost::posix_time::ptime(boost::posix_time::microsec_clock::universal_time()) - |
|||
boost::posix_time::ptime(boost::gregorian::date(1970,1,1))).total_milliseconds(); |
|||
} |
|||
|
|||
int64_t GetTimeMicros() |
|||
{ |
|||
return (boost::posix_time::ptime(boost::posix_time::microsec_clock::universal_time()) - |
|||
boost::posix_time::ptime(boost::gregorian::date(1970,1,1))).total_microseconds(); |
|||
} |
|||
|
|||
void MilliSleep(int64_t n) |
|||
{ |
|||
// Boost's sleep_for was uninterruptable when backed by nanosleep from 1.50
|
|||
// until fixed in 1.52. Use the deprecated sleep method for the broken case.
|
|||
// See: https://svn.boost.org/trac/boost/ticket/7238
|
|||
#if defined(HAVE_WORKING_BOOST_SLEEP_FOR) |
|||
boost::this_thread::sleep_for(boost::chrono::milliseconds(n)); |
|||
#elif defined(HAVE_WORKING_BOOST_SLEEP) |
|||
boost::this_thread::sleep(boost::posix_time::milliseconds(n)); |
|||
#else |
|||
//should never get here
|
|||
#error missing boost sleep implementation |
|||
#endif |
|||
} |
|||
|
|||
std::string DateTimeStrFormat(const char* pszFormat, int64_t nTime) |
|||
{ |
|||
// std::locale takes ownership of the pointer
|
|||
std::locale loc(std::locale::classic(), new boost::posix_time::time_facet(pszFormat)); |
|||
std::stringstream ss; |
|||
ss.imbue(loc); |
|||
ss << boost::posix_time::from_time_t(nTime); |
|||
return ss.str(); |
|||
} |
|||
@ -0,0 +1,20 @@ |
|||
// Copyright (c) 2009-2010 Satoshi Nakamoto
|
|||
// Copyright (c) 2009-2014 The Bitcoin developers
|
|||
// Distributed under the MIT/X11 software license, see the accompanying
|
|||
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
|||
|
|||
#ifndef BITCOIN_UTILTIME_H |
|||
#define BITCOIN_UTILTIME_H |
|||
|
|||
#include <stdint.h> |
|||
#include <string> |
|||
|
|||
int64_t GetTime(); |
|||
int64_t GetTimeMillis(); |
|||
int64_t GetTimeMicros(); |
|||
void SetMockTime(int64_t nMockTimeIn); |
|||
void MilliSleep(int64_t n); |
|||
|
|||
std::string DateTimeStrFormat(const char* pszFormat, int64_t nTime); |
|||
|
|||
#endif |
|||
Loading…
Reference in new issue