StringUtility.h

#ifndef ROSE_StringUtility_H
#define ROSE_StringUtility_H

#include "commandline_processing.h"

#include <BitOps.h>
#include <boost/algorithm/string/erase.hpp>
#include <boost/algorithm/string/predicate.hpp>
#include <boost/algorithm/string/replace.hpp>
#include <limits.h>
#include <map>
#include <rose_constants.h>
#include <sstream>
#include <stdint.h>
#include <string>
#include <vector>
#include <Sawyer/IntervalSet.h>

#if ROSE_MICROSOFT_OS
// This is the boost solution for lack of support for stdint.h (e.g. types such as "uint64_t")
#include <msvc_stdint.h>
#endif

namespace Rose {

namespace StringUtility {




//                                      Character-escaping functions

ROSE_UTIL_API std::string htmlEscape(const std::string&);

ROSE_UTIL_API std::string cEscape(const std::string&, char context = '"');
ROSE_UTIL_API std::string cEscape(char, char context = '\'');
ROSE_UTIL_API std::string cUnescape(const std::string&);

ROSE_UTIL_API std::string bourneEscape(const std::string&);

// [Robb Matzke 2016-05-06]: I am deprecating escapeNewLineCharaters because:
//   1. Its name is spelled wrong: "Charater"
//   2. "newline" in this context is a single word and should be capitalized as "Newline" not "NewLine"
//   3. Its name is misleading because it also escapes double quotes.
//   4. It escapes newlines using "l" rather than the more customary "n".
// I would just remove it, but it seems to be used in some projects and the tutorial.

ROSE_UTIL_API std::string escapeNewLineCharaters(const std::string&);

// DQ (12/8/2016): This is ued in the generation of dot files.
ROSE_UTIL_API std::string escapeNewlineAndDoubleQuoteCharacters(const std::string&);




//                                      Splitting and joining strings

ROSE_UTIL_API std::vector<std::string> split(const std::string &separator, const std::string &str, size_t maxparts = UNLIMITED,
                                             bool trim_white_space = false);
ROSE_UTIL_API std::vector<std::string> split(char separator, const std::string &str, size_t maxparts = UNLIMITED,
                                             bool trim_white_space = false);
ROSE_UTIL_API std::list<std::string> tokenize(const std::string&, char delim);

template<class Iterator>
std::string join_range(const std::string &separator, Iterator begin, Iterator end) {
    std::ostringstream retval;
    for (Iterator i=begin; i!=end; ++i)
        retval <<(i==begin ? std::string() : separator) <<*i;
    return retval.str();
}

template<class Container>
std::string join(const std::string &separator, const Container &container) {
    return join_range(separator, container.begin(), container.end());
}

template<class Container>
std::string join(char separator, const Container &container) {
    return join_range(std::string(1, separator), container.begin(), container.end());
}

ROSE_UTIL_API std::string join(const std::string &separator, char *strings[], size_t nstrings);
ROSE_UTIL_API std::string join(const std::string &separator, const char *strings[], size_t nstrings);
ROSE_UTIL_API std::string join(char separator, char *strings[], size_t nstrings);
ROSE_UTIL_API std::string join(char separator, const char *strings[], size_t nstrings);

ROSE_UTIL_API std::string joinEnglish(const std::vector<std::string> &phrases,
                                      const std::string &separator = ",",
                                      const std::string &finalIntro = "and");



//                                      Container versus scalar functions
//
// Functions that convert containers of things to a string and vice versa.

ROSE_UTIL_API std::string listToString(const std::list<int>&, bool separateStrings = false);

ROSE_UTIL_API std::string listToString(const std::list<std::string>&, bool separateStrings = false);
ROSE_UTIL_API std::string listToString(const std::vector<std::string>&, bool separateStrings = false);
ROSE_UTIL_API std::list<std::string> stringToList(const std::string&);

ROSE_UTIL_API void splitStringIntoStrings(const std::string& inputString, char separator, std::vector<std::string>& stringList);




//                                      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);


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

//                                      Number parsing

ROSE_UTIL_API unsigned hexadecimalToInt(char);

template<class Container, class Stringifier>
std::vector<std::string> toStrings(const Container &numbers, const Stringifier &stringifier=numberToString) {
    return toStrings_range(numbers.begin(), numbers.end(), stringifier);
}
template<class Iterator, class Stringifier>
std::vector<std::string> toStrings_range(Iterator begin, Iterator end, const Stringifier &stringifier=numberToString) {
    std::vector<std::string> retval;
    for (/*void*/; begin!=end; ++begin)
        retval.push_back(stringifier(*begin));
    return retval;
}
//                                      String conversion functions

ROSE_UTIL_API std::string convertToLowerCase(const std::string &inputString);

ROSE_UTIL_API std::string fixLineTermination(const std::string &input);

ROSE_UTIL_API std::string prefixLines(const std::string &lines, const std::string &prefix,
                                      bool prefixAtFront=true, bool prefixAtBack=false);

ROSE_UTIL_API std::string makeOneLine(const std::string &s, std::string replacement=" ");

ROSE_UTIL_API std::string trim(const std::string &str, const std::string &strip=" \t\r\n",
                               bool at_beginning=true, bool at_end=true);

ROSE_UTIL_API std::string untab(const std::string &str, size_t tabstops=8, size_t firstcol=0);

ROSE_UTIL_API std::string removeRedundantSubstrings(const std::string&);



//                                      Functions for string encoding/decoding/hashing

ROSE_UTIL_API std::string encode_base64(const std::vector<uint8_t> &data, bool do_pad=true);
ROSE_UTIL_API std::string encode_base64(const uint8_t *data, size_t nbytes, bool do_padd=true);
ROSE_UTIL_API std::vector<uint8_t> decode_base64(const std::string &encoded);

ROSE_UTIL_API unsigned long generate_checksum(std::string s);




//                                      Predicates

inline bool isContainedIn(const std::string &longString, const std::string &shortString) {
    return longString.find(shortString) != std::string::npos;
}

ROSE_UTIL_API bool isLineTerminated(const std::string &s);




//                                      Functions related to diagnostic messages

ROSE_UTIL_API std::string indentMultilineString(const std::string& inputString, int statementColumnNumber);

ROSE_UTIL_API void add_to_reason_string(std::string &result, bool isset, bool do_pad,
                                        const std::string &abbr, const std::string &full);


ROSE_UTIL_API std::string appendAsmComment(const std::string &s, const std::string &comment);

template<typename T>
std::string plural(T n, const std::string &plural_phrase, const std::string &singular_phrase="") {
    assert(!plural_phrase.empty());
    std::string retval = numberToString(n) + " ";
    if (1==n) {
        if (!singular_phrase.empty()) {
            retval += singular_phrase;
        } else if (boost::ends_with(plural_phrase, "vertices")) {
            retval += boost::replace_tail_copy(plural_phrase, 8, "vertex");
        } else if (boost::ends_with(plural_phrase, "indices")) {
            retval += boost::replace_tail_copy(plural_phrase, 7, "index");
        } else if (boost::ends_with(plural_phrase, "ies") && plural_phrase.size() > 3) {
            // string ends with "ies", as in "parties", so emit "party" instead
            retval += boost::replace_tail_copy(plural_phrase, 3, "y");
        } else if (boost::ends_with(plural_phrase, "sses") || boost::ends_with(plural_phrase, "indexes")) {
            // Sometimes we need to drop an "es" rather than just the "s"
            retval += boost::erase_tail_copy(plural_phrase, 2);
        } else if (boost::ends_with(plural_phrase, "s") && plural_phrase.size() > 1) {
            // strings ends with "s", as in "runners", so drop the final "s" to get "runner"
            retval += boost::erase_tail_copy(plural_phrase, 1);
        } else {
            // I give up.  Use the plural and risk being grammatically incorrect.
            retval += plural_phrase;
        }
    } else {
        retval += plural_phrase;
    }
    return retval;
}

// demangledName is defined in rose_support.cpp
std::string demangledName(std::string);


} // namespace
} // namespace


#endif