string_functions.h

Go to the documentation of this file.

#ifndef ROSE_STRING_UTILITY_H
#define ROSE_STRING_UTILITY_H

// Move this to rose.h or a build a rose_utility.h file later
#include "commandline_processing.h"
#include <vector>
#include <map>
#include <string>
#include <sstream>
#include <stdint.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>
#else
#endif

// DQ (2/22/2014): Used below to control use of __int128 type.
// However, this file can't be included here and must be included 
// in the C source file calling this header file.
// #include "rose_config.h"

// extern const char** roseGlobalVariantNameList;
//Rama: 12/14/06: Changed the class to namespace and removed 'static'ness of the erstwhile "member functions"
//There is still a lot of clean up do be done: Like 
//      reorganize the functions
//      Make a single utililities namespace for ROSE with different functionalites
//      including the functions in util directory.

namespace StringUtility
   {
  // Container class for numerous string utility functions that are useful in different parts of the ROSE project.
  // Rama (12/22/2006): Clearly, some of the following are not string utilities, but file utilities.
  // This class is the wrapper around the realpath of UNIX

     ROSE_UTIL_API std::string getAbsolutePathFromRelativePath ( const std::string & relativePath, bool printErrorIfAny = false); // Real declaration is below

     struct StringWithLineNumber
        {
          std::string str;      // DQ (1/23/2010): this name is difficult to trace within the code.
          std::string filename; // Empty string means generated code
          unsigned int line;

          StringWithLineNumber(const std::string& str, const std::string& filename, unsigned int line): str(str), filename(filename), line(line) {}

          ROSE_UTIL_API std::string toString() const;
        };

#ifndef USE_ROSE
     typedef std::vector<StringWithLineNumber> FileWithLineNumbers;
#else
  // workaround of bug 315, separating definitions for a namespace
  // Liao, 2/16/2009
   }

namespace StringUtility
   {
     typedef std::vector<StringUtility::StringWithLineNumber> FileWithLineNumbers;
#endif

         inline std::ostream& operator<<(std::ostream& os, const StringWithLineNumber& s) {
           os << s.toString();
           return os;
         }

         ROSE_UTIL_API std::string toString(const FileWithLineNumbers& strings, const std::string& filename = "<unknown>", int line = 1);

         inline FileWithLineNumbers& operator+=(FileWithLineNumbers& a, const FileWithLineNumbers& b) {
           a.insert(a.end(), b.begin(), b.end());
           return a;
         }

         inline FileWithLineNumbers operator+(const FileWithLineNumbers& a, const FileWithLineNumbers& b) {
           FileWithLineNumbers f = a;
           f += b;
           return f;
         }

#if 0
         inline std::ostream& operator<<(std::ostream& os, const FileWithLineNumbers& f) {
           os << StringUtility::toString(f);
           return os;
         }
#endif

         inline FileWithLineNumbers& operator<<(FileWithLineNumbers& f, const std::string& str) {
           // Add loose text to the output file
           if (!f.empty() && f.back().filename == "") {
             f.back().str += str;
           } else {
             f.push_back(StringWithLineNumber(str, "", 1));
           }
           return f;
         }

         inline FileWithLineNumbers& operator<<(FileWithLineNumbers& f, const char* str) {
           f << std::string(str);
           return f;
         }

#if 0
         // enum VariantT;
          std::string getVariantName ( int v );
#endif

          ROSE_UTIL_API void  writeFile ( const std::string& outputString, const std::string& fileNameString, const std::string& directoryName );

           ROSE_UTIL_API std::string readFile ( const std::string& fileName );

           ROSE_UTIL_API FileWithLineNumbers readFileWithPos(const std::string& fileName);

           ROSE_UTIL_API std::string copyEdit ( const std::string& inputString, const std::string & oldToken, const std::string & newToken );
           ROSE_UTIL_API std::string numberToString ( long long x );
           ROSE_UTIL_API std::string numberToString ( unsigned long long x );
           ROSE_UTIL_API std::string numberToString ( long x );
           ROSE_UTIL_API std::string numberToString ( unsigned long x );
           ROSE_UTIL_API std::string numberToString ( int x );
           ROSE_UTIL_API std::string numberToString ( unsigned int x );
           ROSE_UTIL_API std::string intToHex(uint64_t i);
       //  string numberToString ( unsigned int x );
       //  ROSE_UTIL_API std::string numberToString ( size_t x );

#ifndef _MSC_VER
// #if !defined(__STRICT_ANSI__) && defined(_GLIBCXX_USE_INT128)
// #if ((BACKEND_CXX_COMPILER_MAJOR_VERSION_NUMBER == 4) && (BACKEND_CXX_COMPILER_MINOR_VERSION_NUMBER > 6))
   #if (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)))
        // DQ (2/22/2014): Required code for GNU versions greater than 4.6.
           ROSE_UTIL_API std::string numberToString ( __int128 x );
           ROSE_UTIL_API std::string numberToString ( unsigned __int128 x );
   #endif
#endif

       // DQ (8/10/2010): Changed to take parameter as const.
           ROSE_UTIL_API std::string numberToString ( const void* x );

           ROSE_UTIL_API std::string numberToString ( double x );

       //  indicates the number of significant bits.
           ROSE_UTIL_API std::string addrToString(uint64_t x, size_t nbits=32);

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

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

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

           ROSE_UTIL_API std::list<std::string> tokenize ( std::string X, char delim );

           ROSE_UTIL_API std::string removeRedundentSubstrings ( std::string X ); // sic
           ROSE_UTIL_API std::string removePseudoRedundentSubstrings ( std::string X ); // sic
           ROSE_UTIL_API void add_to_reason_string(std::string &result, bool isset, bool do_pad,
                                     const std::string &abbr, const std::string &full);
           // int isSameName ( const std::string& s1, const std::string& s2 );

           // char* stringDuplicate ( const char* tempString );
          ROSE_UTIL_API std::string copyEdit ( const std::string& inputString, const std::string& oldToken, const std::string& newToken );
          ROSE_UTIL_API FileWithLineNumbers copyEdit ( const FileWithLineNumbers& inputString, const std::string& oldToken, const std::string& newToken );
          ROSE_UTIL_API FileWithLineNumbers copyEdit ( const FileWithLineNumbers& inputString, const std::string& oldToken, const FileWithLineNumbers& newToken );
       //  bool isContainedIn ( const char* longString, const char* shortString );
           inline bool isContainedIn ( const std::string & longString, const std::string & shortString ) {
             return longString.find(shortString) != std::string::npos;
           }


           // char* stringConcatinate ( const char* targetString , const char* endingString );

           void splitStringIntoStrings( const std::string& inputString, char separator, std::vector<std::string>& stringList );
       //  unsigned short int chksum(char *buffer, int len);
           unsigned long generate_checksum( std::string s );

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

   // std::string mangledName ( std::string s );

      bool popen_wrapper ( const std::string & command, std::vector<std::string> & result );

      std::string demangledName ( std::string s );

//--------------------------------------------------------------

       // DQ (3/5/2006): Copies from ROSE class (deprecated in there previous location)
          ROSE_UTIL_API std::string stripPathFromFileName           ( const std::string & fileNameWithPath ); 
          ROSE_UTIL_API std::string getPathFromFileName             ( const std::string & fileNameWithPath );   
          ROSE_UTIL_API std::string stripFileSuffixFromFileName     ( const std::string & fileNameWithSuffix ); 
           ROSE_UTIL_API std::string getAbsolutePathFromRelativePath ( const std::string & relativePath, bool printErrorIfAny /* = false */ );       
           // If no dot is found in the input fileName, the function just returns the original fileName
           ROSE_UTIL_API std::string fileNameSuffix                  ( const std::string & fileName );          

  // True only if this is a valid C++ source file name extension (suffix). Duplicate of CommandlineProcessing::isCppFileNameSuffix(). 
//           bool isCppFileNameSuffix                    ( const std::string & fileName ); 

       /*
        * The function 
        * findfile
        * traverse the current directory, searching
        * for files with a given string in their name.
        * input:    string to match and directory to match it in.
        * output:   any file found, returned as a list of strings with a full path.
        */
           std::list<std::string> findfile(std::string patternString, std::string pathString);

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

           // RSS 7/1/2008 New functionality to support filename processing
           enum OSType 
                   { 
                                     OS_TYPE_UNKNOWN,
                         OS_TYPE_LINUX,
                         OS_TYPE_OSX,
                         OS_TYPE_WINDOWS,
                                                 OS_TPYE_WINDOWSXP};

           // Return OSType based on uname kernel name results
           ROSE_UTIL_API OSType getOSType();

           // Populate homeDir from $HOME environment var
           void homeDir(std::string& homeDir);

           /* Files can be classified as being in one of three
            * locations: We don't know if it's user or system It is a
            * user (application) file It is a system library This file
            * does not exist */
           enum FileNameLocation 
                               { 
                                                           FILENAME_LOCATION_UNKNOWN, 
                                   FILENAME_LOCATION_USER,    
                                   FILENAME_LOCATION_LIBRARY,
                                   FILENAME_LOCATION_NOT_EXIST };
           
           /* Files can be classified as being part of one of these
            * libraries: Unknown, it isn't a library - it's part of
            * the user application, or any of the libraries that the
            * enum values imply, this list will likely be added to
            * over time */
           /* 
           enum FileNameLibrary { FILENAME_LIBRARY_UNKNOWN,
                                  FILENAME_LIBRARY_USER,
                                  FILENAME_LIBRARY_C,
                                  FILENAME_LIBRARY_STDCXX,
                                  FILENAME_LIBRARY_STL,
                                  FILENAME_LIBRARY_LINUX,
                                  FILENAME_LIBRARY_GCC,
                                  FILENAME_LIBRARY_BOOST,
                                  FILENAME_LIBRARY_ROSE };
                                  */

           static const std::string FILENAME_LIBRARY_UNKNOWN = "Unknown";
           static const std::string FILENAME_LIBRARY_USER = "User";
           static const std::string FILENAME_LIBRARY_C = "C";
           static const std::string FILENAME_LIBRARY_STDCXX = "C++";
           static const std::string FILENAME_LIBRARY_STL = "STL";
           static const std::string FILENAME_LIBRARY_LINUX = "Linux";
           static const std::string FILENAME_LIBRARY_GCC = "GCC";
           static const std::string FILENAME_LIBRARY_BOOST = "Boost";
           static const std::string FILENAME_LIBRARY_ROSE = "Rose";

           // CH (2/16/2010): Use this typedef to avoid following changes
           typedef std::string FileNameLibrary;

           /* This is the return type of classifyFileName, which
            * provides all the details it infers */
           class FileNameClassification
           {
           private:
               FileNameLocation location;

               // CH (2/12/2010): Change 'library' type from enum to string to let user set it
               FileNameLibrary library;
               
               int distance;

           public:
               FileNameClassification(FileNameLocation loc,
                                      const FileNameLibrary& lib,
                                      int dist) : location(loc),
                                                  library(lib),
                                                  distance(dist)
                   {}
               FileNameClassification() : location(FILENAME_LOCATION_UNKNOWN),
                                          library("Unknown"),
                                          distance(0)
                   {}

               /* Return the FileNameLocation which is described above
                * with the definition of the enum */
               FileNameLocation getLocation() const
                   { return location; }

               /* Return the FileNameLibrary which is described above
                * with the definition of the enum */
               FileNameLibrary getLibrary() const
                   { return library; }

               /* Return the "distance" of the filename from the
                * appPath that was supplied during the call.  The
                * distance is defined as the number of cd's that only
                * move up or down one directory that it would take to
                * move from the directory of the filename to the
                * directory that was given by appPath.  This is
                * intended as a heuristic to gage whether or not one
                * believes that the filename is related to the source
                * (appPath) directory.  Examples:
                *
                * Between /a/b/c/file.h and /a/b/d/e/ the distance is 3
                * because one must cd ..; cd d; cd e; to get to appPath
                *
                * *EXCEPTION*: if the appPath is an ancestor of filename
                * then the distance will be 0.  The idea being that this
                * filename is "in" the appPath somewhere and thus part
                * of the application.
                */
               int getDistanceFromSourceDirectory() const
                   { return distance; }

               bool isUserCode() const
                   { return location == FILENAME_LOCATION_USER; }
               bool isLibraryCode() const
                   { return location == FILENAME_LOCATION_LIBRARY; }

               /* Return a string name for the library indicated by
                * getLibrary() */
               std::string getLibraryName() const
                   { return library; }
           };

           /* Given a fileName and an appPath that is a path to some
            * application's source code directory, return a
            * FileNameClassification indicating whether the fileName
            * is part of the source code or some system library and
            * automatically determine the operating system from the
            * host uname */
           ROSE_UTIL_API FileNameClassification classifyFileName(const std::string& fileName,
                                                   const std::string& appPath);

           /* Given a fileName and an appPath that is a path to some
            * application's source code directory, return a
            * FileNameClassification indicating whether the fileName
            * is part of the source code or some system library */
           ROSE_UTIL_API FileNameClassification classifyFileName(const std::string& fileName,
                                                   const std::string& appPath,
                                                   OSType os);

           /* Given a fileName and an appPath that is a path to some
            * application's source code directory, and a collection 
            * of library paths, return a FileNameClassification
            * indicating whether the fileName is part of the source 
            * code or some system library and automatically determine 
            * the operating system from the host uname */
           ROSE_UTIL_API FileNameClassification classifyFileName(const std::string& fileName,
                                                   const std::string& appPath,
                                                   const std::map<std::string, std::string>& libPathCollection);

           /* Given a fileName and an appPath that is a path to some
            * application's source code directory, and a collection 
            * of library paths, return a FileNameClassification
            * indicating whether the fileName is part of the source 
            * code or some system library */ 
           ROSE_UTIL_API FileNameClassification classifyFileName(const std::string& fileName,
                                                   const std::string& appPath,
                                                   const std::map<std::string, std::string>& libPathCollection,
                                                   OSType os);

           /* Remove leading dots plus a space from a header file name
            * that is fiven in the format that g++ -H returns */
           ROSE_UTIL_API const std::string
           stripDotsFromHeaderFileName(const std::string& name);

           /* Essentially the edit distance without substituion in
            * directory name tokens between two directories. Returns
            * the "distance" between left and right. The distance is
            * defined as the number of cd's that only move up or down
            * one directory that it would take to move from the
            * directory of the filename to the directory that was
            * given by appPath.  This is intended as a heuristic to
            * gage whether or not one believes that the left is
            * related to the right directory.  Examples:
            *
            * Between /a/b/c/file.h and /a/b/d/e/ the distance is 3
            * because one must cd ..; cd d; cd e */
            ROSE_UTIL_API int directoryDistance(const std::string& left,
                                  const std::string& right);


            /* Added htmlEscape necessary for QROSE work to this utility library - tps (9Oct2008) */
            ROSE_UTIL_API std::string htmlEscape(const std::string& s);

    // DQ (2/3/2009): Moved this function from attach_all_info.C
       ROSE_UTIL_API std::vector<std::string> readWordsInFile( std::string filename);

   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 appendAsmComment(const std::string &s, const std::string &comment);

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

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

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

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

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

      template<class Container>
      std::string join(const std::string &separator, const Container &strings) {
          return join_range(separator, strings.begin(), strings.end());
      }
      template<class Iterator>
      std::string join_range(const std::string &separator, Iterator begin, Iterator end) {
          std::string retval;
          for (Iterator i=begin; i!=end; ++i)
              retval += (i==begin ? std::string() : separator) + *i;
          return retval;
      }
      std::string join(const std::string &separator, char *strings[], size_t nstrings);
      std::string join(const std::string &separator, const char *strings[], size_t nstrings);
     ROSE_UTIL_API std::vector<std::string> split(const std::string &separator, const std::string &str, size_t maxparts=(size_t)(-1),
                                    bool trim_white_space=false);
     ROSE_UTIL_API std::vector<std::string> split(char separator, const std::string &str, size_t maxparts=(size_t)(-1),
                                    bool trim_white_space=false);

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

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

     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;
     }
    template<typename T>
    std::string plural(T n, const std::string &plural_word) {
        assert(!plural_word.empty());
        std::string retval = numberToString(n) + " ";
        if (1==n) {
            if (plural_word.size()>3 && 0==plural_word.substr(plural_word.size()-3).compare("ies")) {
                // string ends with "ies", as in "parties", so emit "party" instead
                retval += plural_word.substr(0, plural_word.size()-3) + "y";
            } else if (plural_word.size()>1 && plural_word[plural_word.size()-1]=='s') {
                // just drop the final 's'
                retval += plural_word.substr(0, plural_word.size()-1);
            } else {
                // I give up.  Use the plural and risk being grammatically incorrect.
                retval += plural_word;
            }
        } else {
            retval += plural_word;
        }
        return retval;
    }
   
} // namespace

#endif