bbtkUtilities.cxx

Go to the documentation of this file.

/*=========================================================================                                                                               
  Program:   bbtk
  Module:    $RCSfile: bbtkUtilities.cxx,v $
  Language:  C++
  Date:      $Date: 2009/10/05 22:44:48 $
  Version:   $Revision: 1.14 $
=========================================================================*/

/* ---------------------------------------------------------------------

* Copyright (c) CREATIS-LRMN (Centre de Recherche en Imagerie Medicale)
* Authors : Eduardo Davila, Laurent Guigues, Jean-Pierre Roux
*
*  This software is governed by the CeCILL-B license under French law and 
*  abiding by the rules of distribution of free software. You can  use, 
*  modify and/ or redistribute the software under the terms of the CeCILL-B 
*  license as circulated by CEA, CNRS and INRIA at the following URL 
*  http://www.cecill.info/licences/Licence_CeCILL-B_V1-en.html 
*  or in the file LICENSE.txt.
*
*  As a counterpart to the access to the source code and  rights to copy,
*  modify and redistribute granted by the license, users are provided only
*  with a limited warranty  and the software's author,  the holder of the
*  economic rights,  and the successive licensors  have only  limited
*  liability. 
*
*  The fact that you are presently reading this means that you have had
*  knowledge of the CeCILL-B license and that you accept its terms.
* ------------------------------------------------------------------------ */                                                                         


#include "bbtkUtilities.h"
#include "bbtkMessageManager.h"

#if defined(MACOSX) // assume this is OSX 
# include <sys/param.h>
# include <mach-o/dyld.h> // _NSGetExecutablePath : must add -framework CoreFoundation to link line 
# include <string.h>
# ifndef PATH_MAX
#  define PATH_MAX MAXPATHLEN
# endif
#endif // MACOSX

#ifndef PATH_MAX // If not defined yet : do it 
#  define PATH_MAX 2048
#endif 

namespace bbtk
{



            // ======================================================================
    // See : http://www.techbytes.ca/techbyte103.html for more O.S.
    bool Utilities::FileExists(std::string strFilename) 
    {
      struct stat stFileInfo;
     bool blnReturn;
     int intStat;
     
     // Attempt to get the file attributes
     intStat = stat(strFilename.c_str(),&stFileInfo);
     if(intStat == 0) 
       {
         // We were able to get the file attributes
         // so the file obviously exists.
         blnReturn = true;
       } 
     else 
       {
         // We were not able to get the file attributes.
         // This may mean that we don't have permission to
         // access the folder which contains this file. If you
         // need to do that level of checking, lookup the
         // return values of stat which will give you
         // more details on why stat failed.
         blnReturn = false;
       }
     
     return(blnReturn);
    }
    
    
    // =====================================================================
    
    std::string Utilities::ExtractPackageName(const std::string  &name, 
                                          std::string& path)
    {
      std::string pkgname;
      path = "";
      
      std::string::size_type slash_position = name.find_last_of("/\\");
      if (slash_position != std::string::npos) 
        {
          pkgname = name.substr(slash_position+1,std::string::npos);
          path = name.substr(0,slash_position);
          //    std::cout << "F:P='"<<path<<"'"<<std::endl;//+1,std::string::npos);
        }
      else 
        {
          pkgname = name;
        }
      
      // remove {.so | dll} if any
      std::string::size_type dot_position = pkgname.find_last_of('.');      
      if (dot_position != std::string::npos){
        pkgname = pkgname.substr(0,dot_position);
      }      
#if defined(__GNUC__)
      
      // GCC mechanism
      // shared lib name = libbb<name>.so
      
      // remove {libbb} if any
      if (memcmp ( pkgname.c_str(), "libbb", 5) == 0) {
        pkgname =  pkgname.substr(5, pkgname.length());
      }
      /*
      */
#elif defined(_WIN32)
      
      // WIN 32 mechanism
      // shared lib name = <name>.dll
      
      // EED Problem loading package call bbtkTools
      //     // remove {bb} if any
      if (memcmp (pkgname.c_str(), "bb", 2) == 0) {
        pkgname =  pkgname.substr(2, pkgname.length());  
      }
      
      /*
     */
#else
      bbtkError("neither __GNUC__ nor _WIN32 ?!? How did you compile ?");
#endif      
      return pkgname;
    }
    
    //=====================================================================
    std::string Utilities::ExtractScriptName(const std::string &name,
                                         std::string& path)
    {
      std::string pkgname;
      
      std::string::size_type slash_position = name.find_last_of("/\\");
      if (slash_position != std::string::npos) {
        pkgname =name.substr(slash_position+1,std::string::npos);
        path = name.substr(0,slash_position);      
      } else {
        pkgname = name;
      }
      // remove {.bbs } if any
      std::string::size_type dot_position = pkgname.find_last_of('.');
      if (dot_position != std::string::npos){
        pkgname = pkgname.substr(0,dot_position);
      }
      return pkgname;
    }
    
    // ========================================================================

    std::string Utilities::ExpandLibName(const std::string &name, bool verbose)
    {
      // -----   Think of expanding path name ( ./ ../ ../../ )
      
      char buf[2048]; // for getcwd
      char * currentDir = getcwd(buf, 2048);
      std::string cwd(currentDir);
      std::string libname(name);
      std::string fileSeparator;
      fileSeparator = ConfigurationFile::GetInstance().Get_file_separator();
      // tooHigh : true is user supplies a library pathname with too many "../"
      bool tooHigh = false;
      
      //std::cout << "------------------cwd ["  << cwd << "] name [" << name << "]" << std::endl;
      
      if ( name[0] == '/' ||  name[1] == ':' ) // Linux or Windows absolute name
        {
          return(libname);
        }
      else if  ( name =="." )
        {
          libname = cwd  + fileSeparator;
          return(libname);
        }
      else if  (name[0] == '.' && (name[1] == '/' || name[1] == '\\') )
        {
          libname = cwd  + fileSeparator + name.substr(2, name.length());
          return(libname);
        }
      else if ( name[0] == '.' &&  name[1] == '.' /*  && (name[2] == '/' || name[2] == '\\') */ ) 
        {
          if ( IsAtRoot(cwd) )  // hope it gets / (for Linux),  C: D: (for Windows)
      {  
     // if we are already at / or c: --> hopeless  
         if (verbose)
           std::cout << "   File path [" <<  name << "] doesn't exist" << std::endl;
         tooHigh = true;
      }
      else
      {
         // iterate on ../ and go up from the current working dir!
         std::string a(name); 
         bool alreadyProcessRoot = false;

          //if (a[a.size()-1] != fileSeparator[0])
          //   a.append(fileSeparator);
//std::cout << "------------------a ["  << a << "]" << std::endl;

         for(;;)  // wild loop !
         {
            std::string::size_type slash_position = cwd.find_last_of(fileSeparator);
            if (slash_position != std::string::npos) {
             if (slash_position == 0)
                slash_position = 1;
              cwd = cwd.substr(0,slash_position/*+1*/);
//std::cout << "------------------cwd ["  << cwd << "]" << std::endl;
            //  if (a == "..") {
            //    a = "";
            //    break;
            //   }
            //   else
                 a = a.substr(3, /*name.length()*/ a.length());  // remove ../
//std::cout << "------------------a ["  << a << "]" << std::endl;  
              if (a == "" || alreadyProcessRoot)
              {
                if (verbose)
                  std::cout << "   File path : [" <<  name << "] doesn't exist" << std::endl;
                tooHigh = true;
                break;
              }
             // std::string b = cwd + a;
              libname =  cwd;
              char c = cwd[cwd.size()-1];
              if (c != '/' && c != '\\' )
                libname += fileSeparator;
              libname += a;

              if ( a[0] != '.' ) // if . (probabely ../), loop again
                break;

              if (IsAtRoot(cwd))
                alreadyProcessRoot = true;
            }
         } // end iterating on ../
      }
//std::cout << "------------------out of loop]" << std::endl;        
      if (tooHigh)
         libname="";
      return (libname);

    }  // -----   End of expanding path name   ( ./ ../ ../../ )

    std::cout <<"* ERROR in ExpandLibName : should never get here!" << std::endl;
    // To avoid warning
    return(""); // Will never get here!
  }

// ===================================================================================

  std::string Utilities::MakeLibnameFromPath(std::string path, std::string pkgname)
  {
    std::string libname = path;
        if(path.size()>0){
                char c = path[path.size()-1];    
#if defined(__GNUC__)
       if (c != '/')
          libname += "/libbb";
       else
          libname += "libbb";
       libname += pkgname;
#if defined(MACOSX)
          libname += ".dylib";
#else
          libname += ".so";
#endif  
          
#elif defined(_WIN32)
       if (c != '\\') 
          libname += "\\bb";
       else
          libname += "bb";
       libname += pkgname;
       libname += ".dll";
#endif
        }
    
    return libname;    
  }

// ===================================================================================

  std::string Utilities::MakePkgnameFromPath(std::string path, std::string pkgname, bool addExt)
  {
    std::string libname = path;
        if(path.size()>0){
                char c = path[path.size()-1];
                if (c != '/' && c != '\\')
                {
                   libname +=  ConfigurationFile::GetInstance().Get_file_separator ();
                }
                libname += pkgname;
                if (addExt)
                {
                   int l = libname.size();
                   if (l>4)
                   {
                          if (libname.substr(l-4, 4) != ".bbs")
                          {
                                   libname = libname + ".bbs";
                          }
                   }
                }
        }
    
    return libname;
  }
  // =======================================================================

  // =======================================================================
  std::string Utilities::GetUserSettingsDir()
  {
#if defined(__GNUC__)
    std::string str_home(getenv("HOME"));
#elif defined(_WIN32)
    std::string str_home(getenv("USERPROFILE"));
#endif
    std::string fullname = str_home + "/.bbtk";
    MakeValidFileName(fullname);
    return fullname;
  }
  

  // =======================================================================
  std::string Utilities::MakeUserSettingsFullFileName(const std::string& name)
  {
#if defined(__GNUC__)
    std::string str_home(getenv("HOME"));
#elif defined(_WIN32)
    std::string str_home(getenv("USERPROFILE"));
#endif
    std::string fullname = str_home + "/.bbtk/" + name;
    MakeValidFileName(fullname);
    return fullname;
  }
  // =======================================================================
  

  // =======================================================================
  void Utilities::CreateDirectoryIfNeeded( std::string const &dirName)
  {
    if (FileExists(dirName)) return;
    std::string cmd("mkdir \"");
    cmd += dirName;
    cmd += "\"";
    system(cmd.c_str());
  }  
  // =======================================================================
  
  
  //========================================================================
  bool Utilities::IsAtRoot(std::string cwd)
  {
    if ( cwd == "/"              // hope it gets /     (for Linux)
         || (cwd.size() <= 3 && cwd[1] == ':') ) // hope it gets C: D: (for Windows)
      return (true);
    else
      return(false);
  }
  // ======================================================================

  // ======================================================================
  bool Utilities::IsDirectory(std::string const &dirName)
  {
    struct stat fs;
    
    if ( stat(dirName.c_str(), &fs) == 0 )
      {
#if _WIN32
        return ((fs.st_mode & _S_IFDIR) != 0);
#else
        return S_ISDIR(fs.st_mode);
#endif
      }
    else
      {
        return false;
      }
  }
  // =======================================================================
    
  // =======================================================================
  void Utilities::SplitAroundFirstDot( const std::string& in,
                                       std::string& left,
                                       std::string& right)
  {
    std::string delimiter = ".";
    std::string::size_type pos = in.find_first_of(delimiter);
    if (std::string::npos != pos) 
      {
        left = in.substr(0,pos);
        right = in.substr(pos+1,in.size());
        
      }
    else
      {
        left ="";
        right = "";
        bbtkGlobalError("Token '"<<in<<"' : expected 'a.b' format but no dot found");
      }
  }
  //=======================================================================

  //=======================================================================
  void Utilities::SplitString ( const std::string& str, 
                                const std::string& delimiters, 
                                std::vector<std::string>& tokens)
  {
    // Skip delimiters at beginning.
    std::string::size_type lastPos = str.find_first_not_of(delimiters, 0);
    // Find first delimiter.
    std::string::size_type pos     = str.find_first_of(delimiters, lastPos);
    
    while (std::string::npos != pos || std::string::npos != lastPos)
      {
        // Found a token, add it to the vector.
        tokens.push_back(str.substr(lastPos, pos - lastPos));
        // Skip delimiters.  Note the "not_of"
        lastPos = str.find_first_not_of(delimiters, pos);
        // Find next delimiter
        pos = str.find_first_of(delimiters, lastPos);
      }
    
  }
  //=======================================================================
  
  
  // ======================================================================
  std::string Utilities::get_file_name(const std::string& s) 
  { 
    std::string::size_type slash_position = s.find_last_of("/\\");
    if (slash_position != std::string::npos) 
      {
        return  s.substr(slash_position+1,std::string::npos);   
      }
    else 
      {
        return s;
      }
  }
  //=======================================================================
 

  // ========================================================================
  int Utilities::Explore(std::string const &dirpath, bool recursive, std::vector<std::string> &Filenames)
  {
    int numberOfFiles = 0;
    std::string fileName;
      
      std::string dirName = dirpath;
      
#ifdef _MSC_VER
      WIN32_FIND_DATA fileData;
   HANDLE hFile = FindFirstFile((dirName+"\\*").c_str(), &fileData);

   for(BOOL b = (hFile != INVALID_HANDLE_VALUE); b;
       b = FindNextFile(hFile, &fileData))
   {
      fileName = fileData.cFileName;
      if ( fileData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY )
      {
         // Need to check for . and .. to avoid infinite loop
         if ( fileName != "." && fileName != ".." && recursive )
         {
            numberOfFiles += Explore(dirName+ "\\"+fileName,recursive,Filenames);
         }
      }
      else
      {
         Filenames.push_back(dirName+"\\"+fileName);
         numberOfFiles++;
      }
   }
   DWORD dwError = GetLastError();
   if (hFile != INVALID_HANDLE_VALUE) 
      FindClose(hFile);
   if (dwError != ERROR_NO_MORE_FILES) 
   {
      LPVOID lpMsgBuf;
      FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER|
                    FORMAT_MESSAGE_FROM_SYSTEM|
                    FORMAT_MESSAGE_IGNORE_INSERTS,
                    NULL,GetLastError(),
                    MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language
                    (LPTSTR) &lpMsgBuf,0,NULL);

     // ErrorMacro("FindNextFile error. Error is " << (char *)lpMsgBuf
     //             <<" for the directory : "<<dirName);
      
      return 0;
   }

#else
  // Real POSIX implementation: scandir is a BSD extension only, and doesn't 
  // work on debian for example
//std::cout <<"in Explor dirname[" << dirName << "]" << std::endl; 
   DIR* dir = opendir(dirName.c_str());
   if (!dir)
   {
      return 0;
   }
//std::cout <<"Open OK" << std::endl; 
   // According to POSIX, the dirent structure contains a field char d_name[]
   // of unspecified size, with at most NAME_MAX characters preceeding the
   // terminating null character. Use of other fields will harm the  porta-
   // bility of your programs.

   struct stat buf;
   dirent *d;
   for (d = readdir(dir); d; d = readdir(dir))
   {
      fileName = dirName + "/" + d->d_name;
//std::cout <<"in Explor filename[" << fileName << "]" << std::endl;      
      if( stat(fileName.c_str(), &buf) != 0 )
      {
         //ErrorMacro( strerror(errno) );
      }
      if ( S_ISREG(buf.st_mode) )    //is it a regular file?
      {
         Filenames.push_back( fileName );
         numberOfFiles++;
      }
      else if ( S_ISDIR(buf.st_mode) ) //directory?
      {
         if ( d->d_name[0] != '.' && recursive ) //we also skip hidden files
         {
            numberOfFiles += Explore( fileName, recursive, Filenames);
         }
      }
      else
      {
         //ErrorMacro( "Unexpected error" );
         return -1;
      }
   }
   if( closedir(dir) != 0 )
   {
     // ErrorMacro( strerror(errno) );
   }
#endif

  return numberOfFiles;

}
  //=======================================================================
 

    //=======================================================================
    // Replaces substrings "\\n" by a real carriage return "\n"
    void Utilities::SubsBackslashN ( std::string& s )
    {
      std::string ss("\\n");
      std::string::size_type pos = 0;
      pos = s.find(ss,0);
      const char* cr = "\n";
      while ( pos != std::string::npos )
        {
          s.replace(pos,2,cr,1);
          pos = s.find(ss, pos-1);
        }
    }
    //=======================================================================


   //=======================================================================

  bool Utilities::loosematch(std::string stdLine,std::string stdOptions) 
  {
    bool result=false;
    std::vector<std::string> tokens;
    SplitString ( stdOptions,"|", tokens);
    int i,size=tokens.size();  
    for (i=0; i<size; i++)
      {           
#ifdef WIN32
        if ( strcmpi(stdLine.c_str(),tokens[i].c_str())==0) 
          { 
            result=true; 
          }               
#else
        if ( strcasecmp(stdLine.c_str(),tokens[i].c_str())==0) 
          { 
            result=true; 
          }               
#endif
        
      }
    return result;
  }
  //=========================================================================  
  
  //=========================================================================  
  // From http://www.fltk.org/newsgroups.php?gfltk.general+v:22083
  //
  int get_app_path (char *pname, size_t pathsize)
  {
#ifdef LINUX
    /* Oddly, the readlink(2) man page says no NULL is appended. */
    /* So you have to do it yourself, based on the return value: */
    pathsize --; /* Preserve a space to add the trailing NULL */
    long result = readlink("/proc/self/exe", pname, pathsize);
    if (result > 0)
      {
        pname[result] = 0; /* add the #@!%ing NULL */
        
        if ((access(pname, 0) == 0))
          return 0; /* file exists, return OK */
        /*else name doesn't seem to exist, return FAIL (falls
          through) */
      }
#endif /* LINUX */
    
#ifdef WIN32
    long result = GetModuleFileName(NULL, pname, pathsize);
    if (result > 0)
      {
        /* fix up the dir slashes... */
        int len = strlen(pname);
        int idx;
        for (idx = 0; idx < len; idx++)
          {
            if (pname[idx] == '\\') pname[idx] = '/';
          }
        
        for (idx = len-1; idx >=0 ; idx--)
          {
            if (pname[idx] == '/')
              { 
                pname[idx+1] = '\0';
                idx = -1;
              }
          }
        
        if ((access(pname, 0) == 0))
          return 0; /* file exists, return OK */
        /*else name doesn't seem to exist, return FAIL (falls
          through) */
      }
#endif /* WIN32 */
    
#ifdef SOLARIS
    char *p = getexecname();
    if (p)
      {
        /* According to the Sun manpages, getexecname will
           "normally" return an */
        /* absolute path - BUT might not... AND that IF it is not,
           pre-pending */
        /* getcwd() will "usually" be the correct thing... Urgh!
         */
        
        /* check pathname is absolute (begins with a / ???) */
        if (p[0] == '/') /* assume this means we have an
                            absolute path */
          {
            strncpy(pname, p, pathsize);
            if ((access(pname, 0) == 0))
              return 0; /* file exists, return OK */
          }
        else /* if not, prepend getcwd() then check if file
                exists */
          {
            getcwd(pname, pathsize);
            long result = strlen(pname);
            strncat(pname, "/", (pathsize - result));
            result ++;
            strncat(pname, p, (pathsize - result));
            
            if ((access(pname, 0) == 0))
              return 0; /* file exists, return OK */
            /*else name doesn't seem to exist, return FAIL
              (falls through) */
          }
      }
#endif /* SOLARIS */
    
#ifdef MACOSX /* assume this is OSX */
    /*
      from http://www.hmug.org/man/3/NSModule.html
      
      extern int _NSGetExecutablePath(char *buf, unsigned long
      *bufsize);
      
      _NSGetExecutablePath  copies  the  path  of the executable
      into the buffer and returns 0 if the path was successfully
      copied  in the provided buffer. If the buffer is not large
      enough, -1 is returned and the  expected  buffer  size  is
      copied  in  *bufsize.  Note that _NSGetExecutablePath will
      return "a path" to the executable not a "real path" to the
      executable.  That  is  the path may be a symbolic link and
      not the real file. And with  deep  directories  the  total
      bufsize needed could be more than MAXPATHLEN.
    */
    int status = -1;
    char *given_path = (char*)malloc(MAXPATHLEN * 2);
    if (!given_path) return status;
    
    uint32_t npathsize = MAXPATHLEN * 2;
    long result = _NSGetExecutablePath(given_path, &npathsize);
    if (result == 0)
      { /* OK, we got something - now try and resolve the real path...
         */
        if (realpath(given_path, pname) != NULL)
          {
            if ((access(pname, 0) == 0))
              status = 0; /* file exists, return OK */
          }
      }
    free (given_path);
    return status;
#endif /* MACOSX */
    
    return -1; /* Path Lookup Failed */
  } 
  //=========================================================================
        

        
  //=========================================================================
  std::string Utilities::GetExecutablePath()
  {
    char name[PATH_MAX];
    int err = get_app_path(name, PATH_MAX);
    if (err) 
      {
        bbtkGlobalError("Could not determine current executable path ?");  
      }
    
    // remove the exe name
    char *slash;                
    slash = strrchr(name, VALID_FILE_SEPARATOR_CHAR);
    if (slash)
      {
        *slash = 0;
      }
    return name;
  }
  //=========================================================================



}