NumberToString.h

#ifndef ROSE_StringUtility_NumberToString_H
#define ROSE_StringUtility_NumberToString_H
 
#include <Rose/BitOps.h>
#include <rosedll.h>
 
#include <Sawyer/IntervalSet.h>
#include <string>
 
namespace Rose {
namespace StringUtility {
 
//                                      Functions for converting numbers to strings
 
ROSE_UTIL_API std::string numberToString(long long);
ROSE_UTIL_API std::string numberToString(unsigned long long);
ROSE_UTIL_API std::string numberToString(long);
ROSE_UTIL_API std::string numberToString(unsigned long);
ROSE_UTIL_API std::string numberToString(int);
ROSE_UTIL_API std::string numberToString(unsigned int);
 
#if !defined(_MSC_VER) &&                                                                                                      \
    defined(BACKEND_CXX_IS_GNU_COMPILER) &&                                                                                    \
    ((BACKEND_CXX_COMPILER_MAJOR_VERSION_NUMBER == 4 && BACKEND_CXX_COMPILER_MINOR_VERSION_NUMBER > 6) ||                      \
     BACKEND_CXX_COMPILER_MAJOR_VERSION_NUMBER > 4) &&                                                                         \
    __WORDSIZE == 64
ROSE_UTIL_API std::string numberToString(__int128 x);
ROSE_UTIL_API std::string numberToString(unsigned __int128 x);
#endif
 
ROSE_UTIL_API std::string numberToString(const void*);
 
ROSE_UTIL_API std::string numberToString(double);
 
ROSE_UTIL_API std::string intToHex(uint64_t);
 
ROSE_UTIL_API std::string toHex2(uint64_t value, size_t nbits,
                                 bool show_unsigned_decimal=true, bool show_signed_decimal=true,
                                 uint64_t decimal_threshold=256);
ROSE_UTIL_API std::string signedToHex2(uint64_t value, size_t nbits);
ROSE_UTIL_API std::string unsignedToHex2(uint64_t value, size_t nbits);
 
template<typename T>
std::string toHex(T value) {
    return toHex2((uint64_t)value, 8*sizeof(T));
}
 
template<typename T>
std::string signedToHex(T value) {
    return signedToHex2((uint64_t)value, 8*sizeof(T));
}
 
template<typename T>
std::string unsignedToHex(T value) {
    return unsignedToHex2((uint64_t)value, 8*sizeof(T));
}
ROSE_UTIL_API std::string addrToString(uint64_t value, size_t nbits = 0);
 
ROSE_UTIL_API std::string addrToString(const Sawyer::Container::Interval<uint64_t> &interval, size_t nbits = 0);
 
ROSE_UTIL_API std::string addrToString(const Sawyer::Container::IntervalSet<Sawyer::Container::Interval<uint64_t> > &iset,
                                       size_t nbits = 0);
 
ROSE_UTIL_API std::string addrToString(const Sawyer::Optional<uint64_t>&, size_t nbits = 0);
 
template<typename Unsigned>
std::string toBinary(Unsigned value, size_t nBits = 0, size_t groupSize = 4, const std::string groupSeparator = "_") {
    if (0 == nBits)
        nBits = BitOps::nBits(value);
    std::string retval;
    for (size_t i = nBits; i > 0; --i) {
        retval += BitOps::bit(value, i-1) ? '1' : '0';
        if (groupSize > 0 && i > 1 && (i-1) % groupSize == 0)
            retval += groupSeparator;
    }
    return retval;
}
 
} // namespace
} // namespace
 
#endif