kernel/src/bbtkUtilities.cxx

   1 /*=========================================================================
   2   Program:   bbtk
   3   Module:    $RCSfile: bbtkUtilities.cxx,v $
   4   Language:  C++
   5   Date:      $Date: 2009/10/05 22:44:48 $
   6   Version:   $Revision: 1.14 $
   7 =========================================================================*/
   8
   9 /* ---------------------------------------------------------------------
  10
  11 * Copyright (c) CREATIS-LRMN (Centre de Recherche en Imagerie Medicale)
  12 * Authors : Eduardo Davila, Laurent Guigues, Jean-Pierre Roux
  13 *
  14 *  This software is governed by the CeCILL-B license under French law and
  15 *  abiding by the rules of distribution of free software. You can  use,
  16 *  modify and/ or redistribute the software under the terms of the CeCILL-B
  17 *  license as circulated by CEA, CNRS and INRIA at the following URL
  18 *  http://www.cecill.info/licences/Licence_CeCILL-B_V1-en.html
  19 *  or in the file LICENSE.txt.
  20 *
  21 *  As a counterpart to the access to the source code and  rights to copy,
  22 *  modify and redistribute granted by the license, users are provided only
  23 *  with a limited warranty  and the software's author,  the holder of the
  24 *  economic rights,  and the successive licensors  have only  limited
  25 *  liability.
  26 *
  27 *  The fact that you are presently reading this means that you have had
  28 *  knowledge of the CeCILL-B license and that you accept its terms.
  29 * ------------------------------------------------------------------------ */
  30
  31
  32 #include "bbtkUtilities.h"
  33 #include "bbtkMessageManager.h"
  34
  35 #if defined(MACOSX) // assume this is OSX
  36 # include <sys/param.h>
  37 # include <mach-o/dyld.h> // _NSGetExecutablePath : must add -framework CoreFoundation to link line
  38 # include <string.h>
  39 # ifndef PATH_MAX
  40 #  define PATH_MAX MAXPATHLEN
  41 # endif
  42 #endif // MACOSX
  43
  44 #ifndef PATH_MAX // If not defined yet : do it
  45 #  define PATH_MAX 2048
  46 #endif
  47
  48 namespace bbtk
  49 {
  50
  51
  52
  53             // ======================================================================
  54     // See : http://www.techbytes.ca/techbyte103.html for more O.S.
  55     bool Utilities::FileExists(std::string strFilename)
  56     {
  57       struct stat stFileInfo;
  58      bool blnReturn;
  59      int intStat;
  60
  61      // Attempt to get the file attributes
  62      intStat = stat(strFilename.c_str(),&stFileInfo);
  63      if(intStat == 0)
  64        {
  65          // We were able to get the file attributes
  66          // so the file obviously exists.
  67          blnReturn = true;
  68        }
  69      else
  70        {
  71          // We were not able to get the file attributes.
  72          // This may mean that we don't have permission to
  73          // access the folder which contains this file. If you
  74          // need to do that level of checking, lookup the
  75          // return values of stat which will give you
  76          // more details on why stat failed.
  77          blnReturn = false;
  78        }
  79
  80      return(blnReturn);
  81     }
  82
  83
  84     // =====================================================================
  85
  86     std::string Utilities::ExtractPackageName(const std::string  &name,
  87                                           std::string& path)
  88     {
  89       std::string pkgname;
  90       path = "";
  91
  92       std::string::size_type slash_position = name.find_last_of("/\\");
  93       if (slash_position != std::string::npos)
  94         {
  95           pkgname = name.substr(slash_position+1,std::string::npos);
  96           path = name.substr(0,slash_position);
  97           //    std::cout << "F:P='"<<path<<"'"<<std::endl;//+1,std::string::npos);
  98         }
  99       else
 100         {
 101           pkgname = name;
 102         }
 103
 104       // remove {.so | dll} if any
 105       std::string::size_type dot_position = pkgname.find_last_of('.');
 106       if (dot_position != std::string::npos){
 107         pkgname = pkgname.substr(0,dot_position);
 108       }
 109 #if defined(__GNUC__)
 110
 111       // GCC mechanism
 112       // shared lib name = libbb<name>.so
 113
 114       // remove {libbb} if any
 115       if (memcmp ( pkgname.c_str(), "libbb", 5) == 0) {
 116         pkgname =  pkgname.substr(5, pkgname.length());
 117       }
 118       /*
 119      /// \ \todo     what would happen if (stupid) user names his package 'libbb' ?!?
 120       /// \ --> Should be forbidden!
 121       */
 122 #elif defined(_WIN32)
 123
 124       // WIN 32 mechanism
 125       // shared lib name = <name>.dll
 126
 127       // EED Problem loading package call bbtkTools
 128       //     // remove {bb} if any
 129       if (memcmp (pkgname.c_str(), "bb", 2) == 0) {
 130         pkgname =  pkgname.substr(2, pkgname.length());
 131       }
 132
 133       /*
 134      /// \ \todo     what would happen if (stupid) user names his package 'bb' ?!?
 135      /// \ --> Should be forbidden!
 136      */
 137 #else
 138       bbtkError("neither __GNUC__ nor _WIN32 ?!? How did you compile ?");
 139 #endif
 140       return pkgname;
 141     }
 142
 143     //=====================================================================
 144     std::string Utilities::ExtractScriptName(const std::string &name,
 145                                          std::string& path)
 146     {
 147       std::string pkgname;
 148
 149       std::string::size_type slash_position = name.find_last_of("/\\");
 150       if (slash_position != std::string::npos) {
 151         pkgname =name.substr(slash_position+1,std::string::npos);
 152         path = name.substr(0,slash_position);
 153       } else {
 154         pkgname = name;
 155       }
 156       // remove {.bbs } if any
 157       std::string::size_type dot_position = pkgname.find_last_of('.');
 158       if (dot_position != std::string::npos){
 159         pkgname = pkgname.substr(0,dot_position);
 160       }
 161       return pkgname;
 162     }
 163
 164     // ========================================================================
 165
 166     std::string Utilities::ExpandLibName(const std::string &name, bool verbose)
 167     {
 168       // -----   Think of expanding path name ( ./ ../ ../../ )
 169
 170       char buf[2048]; // for getcwd
 171       char * currentDir = getcwd(buf, 2048);
 172       std::string cwd(currentDir);
 173       std::string libname(name);
 174       std::string fileSeparator;
 175       fileSeparator = ConfigurationFile::GetInstance().Get_file_separator();
 176       // tooHigh : true is user supplies a library pathname with too many "../"
 177       bool tooHigh = false;
 178
 179       //std::cout << "------------------cwd ["  << cwd << "] name [" << name << "]" << std::endl;
 180
 181       if ( name[0] == '/' ||  name[1] == ':' ) // Linux or Windows absolute name
 182         {
 183           return(libname);
 184         }
 185       else if  ( name =="." )
 186         {
 187           libname = cwd  + fileSeparator;
 188           return(libname);
 189         }
 190       else if  (name[0] == '.' && (name[1] == '/' || name[1] == '\\') )
 191         {
 192           libname = cwd  + fileSeparator + name.substr(2, name.length());
 193           return(libname);
 194         }
 195       else if ( name[0] == '.' &&  name[1] == '.' /*  && (name[2] == '/' || name[2] == '\\') */ )
 196         {
 197           if ( IsAtRoot(cwd) )  // hope it gets / (for Linux),  C: D: (for Windows)
 198       {
 199      // if we are already at / or c: --> hopeless
 200          if (verbose)
 201            std::cout << "   File path [" <<  name << "] doesn't exist" << std::endl;
 202          tooHigh = true;
 203       }
 204       else
 205       {
 206          // iterate on ../ and go up from the current working dir!
 207          std::string a(name);
 208          bool alreadyProcessRoot = false;
 209
 210           //if (a[a.size()-1] != fileSeparator[0])
 211           //   a.append(fileSeparator);
 212 //std::cout << "------------------a ["  << a << "]" << std::endl;
 213
 214          for(;;)  // wild loop !
 215          {
 216             std::string::size_type slash_position = cwd.find_last_of(fileSeparator);
 217             if (slash_position != std::string::npos) {
 218              if (slash_position == 0)
 219                 slash_position = 1;
 220               cwd = cwd.substr(0,slash_position/*+1*/);
 221 //std::cout << "------------------cwd ["  << cwd << "]" << std::endl;
 222             //  if (a == "..") {
 223             //    a = "";
 224             //    break;
 225             //   }
 226             //   else
 227                  a = a.substr(3, /*name.length()*/ a.length());  // remove ../
 228 //std::cout << "------------------a ["  << a << "]" << std::endl;
 229               if (a == "" || alreadyProcessRoot)
 230               {
 231                 if (verbose)
 232                   std::cout << "   File path : [" <<  name << "] doesn't exist" << std::endl;
 233                 tooHigh = true;
 234                 break;
 235               }
 236              // std::string b = cwd + a;
 237               libname =  cwd;
 238               char c = cwd[cwd.size()-1];
 239               if (c != '/' && c != '\\' )
 240                 libname += fileSeparator;
 241               libname += a;
 242
 243               if ( a[0] != '.' ) // if . (probabely ../), loop again
 244                 break;
 245
 246               if (IsAtRoot(cwd))
 247                 alreadyProcessRoot = true;
 248             }
 249          } // end iterating on ../
 250       }
 251 //std::cout << "------------------out of loop]" << std::endl;
 252       if (tooHigh)
 253          libname="";
 254       return (libname);
 255
 256     }  // -----   End of expanding path name   ( ./ ../ ../../ )
 257
 258     std::cout <<"* ERROR in ExpandLibName : should never get here!" << std::endl;
 259     // To avoid warning
 260     return(""); // Will never get here!
 261   }
 262
 263 // ===================================================================================
 264
 265   std::string Utilities::MakeLibnameFromPath(std::string path, std::string pkgname)
 266   {
 267     std::string libname = path;
 268         if(path.size()>0){
 269                 char c = path[path.size()-1];
 270 #if defined(__GNUC__)
 271        if (c != '/')
 272           libname += "/libbb";
 273        else
 274           libname += "libbb";
 275        libname += pkgname;
 276 #if defined(MACOSX)
 277           libname += ".dylib";
 278 #else
 279           libname += ".so";
 280 #endif
 281
 282 #elif defined(_WIN32)
 283        if (c != '\\')
 284           libname += "\\bb";
 285        else
 286           libname += "bb";
 287        libname += pkgname;
 288        libname += ".dll";
 289 #endif
 290         }
 291
 292     return libname;
 293   }
 294
 295 // ===================================================================================
 296
 297   std::string Utilities::MakePkgnameFromPath(std::string path, std::string pkgname, bool addExt)
 298   {
 299     std::string libname = path;
 300         if(path.size()>0){
 301                 char c = path[path.size()-1];
 302                 if (c != '/' && c != '\\')
 303                 {
 304                    libname +=  ConfigurationFile::GetInstance().Get_file_separator ();
 305                 }
 306                 libname += pkgname;
 307                 if (addExt)
 308                 {
 309                    int l = libname.size();
 310                    if (l>4)
 311                    {
 312                           if (libname.substr(l-4, 4) != ".bbs")
 313                           {
 314                                    libname = libname + ".bbs";
 315                           }
 316                    }
 317                 }
 318         }
 319
 320     return libname;
 321   }
 322   // =======================================================================
 323
 324   // =======================================================================
 325   /// Returns the user settings dir, e.g. /home/username/.bbtk
 326   std::string Utilities::GetUserSettingsDir()
 327   {
 328 #if defined(__GNUC__)
 329     std::string str_home(getenv("HOME"));
 330 #elif defined(_WIN32)
 331     std::string str_home(getenv("USERPROFILE"));
 332 #endif
 333     std::string fullname = str_home + "/.bbtk";
 334     MakeValidFileName(fullname);
 335     return fullname;
 336   }
 337
 338
 339   // =======================================================================
 340   /// Builds the complete path to the file 'name' located
 341   /// in user settings dir, e.g. /home/username/.bbtk/
 342   std::string Utilities::MakeUserSettingsFullFileName(const std::string& name)
 343   {
 344 #if defined(__GNUC__)
 345     std::string str_home(getenv("HOME"));
 346 #elif defined(_WIN32)
 347     std::string str_home(getenv("USERPROFILE"));
 348 #endif
 349     std::string fullname = str_home + "/.bbtk/" + name;
 350     MakeValidFileName(fullname);
 351     return fullname;
 352   }
 353   // =======================================================================
 354
 355
 356   // =======================================================================
 357   void Utilities::CreateDirectoryIfNeeded( std::string const &dirName)
 358   {
 359     if (FileExists(dirName)) return;
 360     std::string cmd("mkdir \"");
 361     cmd += dirName;
 362     cmd += "\"";
 363     system(cmd.c_str());
 364   }
 365   // =======================================================================
 366
 367
 368   //========================================================================
 369   bool Utilities::IsAtRoot(std::string cwd)
 370   {
 371     if ( cwd == "/"              // hope it gets /     (for Linux)
 372          || (cwd.size() <= 3 && cwd[1] == ':') ) // hope it gets C: D: (for Windows)
 373       return (true);
 374     else
 375       return(false);
 376   }
 377   // ======================================================================
 378
 379   // ======================================================================
 380   bool Utilities::IsDirectory(std::string const &dirName)
 381   {
 382     struct stat fs;
 383
 384     if ( stat(dirName.c_str(), &fs) == 0 )
 385       {
 386 #if _WIN32
 387         return ((fs.st_mode & _S_IFDIR) != 0);
 388 #else
 389         return S_ISDIR(fs.st_mode);
 390 #endif
 391       }
 392     else
 393       {
 394         return false;
 395       }
 396   }
 397   // =======================================================================
 398
 399   // =======================================================================
 400   void Utilities::SplitAroundFirstDot( const std::string& in,
 401                                        std::string& left,
 402                                        std::string& right)
 403   {
 404     std::string delimiter = ".";
 405     std::string::size_type pos = in.find_first_of(delimiter);
 406     if (std::string::npos != pos)
 407       {
 408         left = in.substr(0,pos);
 409         right = in.substr(pos+1,in.size());
 410
 411       }
 412     else
 413       {
 414         left ="";
 415         right = "";
 416         bbtkGlobalError("Token '"<<in<<"' : expected 'a.b' format but no dot found");
 417       }
 418   }
 419   //=======================================================================
 420
 421   //=======================================================================
 422   void Utilities::SplitString ( const std::string& str,
 423                                 const std::string& delimiters,
 424                                 std::vector<std::string>& tokens)
 425   {
 426     // Skip delimiters at beginning.
 427     std::string::size_type lastPos = str.find_first_not_of(delimiters, 0);
 428     // Find first delimiter.
 429     std::string::size_type pos     = str.find_first_of(delimiters, lastPos);
 430
 431     while (std::string::npos != pos || std::string::npos != lastPos)
 432       {
 433         // Found a token, add it to the vector.
 434         tokens.push_back(str.substr(lastPos, pos - lastPos));
 435         // Skip delimiters.  Note the "not_of"
 436         lastPos = str.find_first_not_of(delimiters, pos);
 437         // Find next delimiter
 438         pos = str.find_first_of(delimiters, lastPos);
 439       }
 440
 441   }
 442   //=======================================================================
 443
 444
 445   // ======================================================================
 446   std::string Utilities::get_file_name(const std::string& s)
 447   {
 448     std::string::size_type slash_position = s.find_last_of("/\\");
 449     if (slash_position != std::string::npos)
 450       {
 451         return  s.substr(slash_position+1,std::string::npos);
 452       }
 453     else
 454       {
 455         return s;
 456       }
 457   }
 458   //=======================================================================
 459
 460
 461   // ========================================================================
 462   /**
 463    * \brief   Explore a directory with possibility of recursion
 464    *          return number of files read
 465    * @param  dirpath   directory to explore
 466    * @param  recursive whether we want recursion or not
 467    */
 468   int Utilities::Explore(std::string const &dirpath, bool recursive, std::vector<std::string> &Filenames)
 469   {
 470     int numberOfFiles = 0;
 471     std::string fileName;
 472
 473       std::string dirName = dirpath;
 474
 475 #ifdef _MSC_VER
 476       WIN32_FIND_DATA fileData;
 477    HANDLE hFile = FindFirstFile((dirName+"\\*").c_str(), &fileData);
 478
 479    for(BOOL b = (hFile != INVALID_HANDLE_VALUE); b;
 480        b = FindNextFile(hFile, &fileData))
 481    {
 482       fileName = fileData.cFileName;
 483       if ( fileData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY )
 484       {
 485          // Need to check for . and .. to avoid infinite loop
 486          if ( fileName != "." && fileName != ".." && recursive )
 487          {
 488             numberOfFiles += Explore(dirName+ "\\"+fileName,recursive,Filenames);
 489          }
 490       }
 491       else
 492       {
 493          Filenames.push_back(dirName+"\\"+fileName);
 494          numberOfFiles++;
 495       }
 496    }
 497    DWORD dwError = GetLastError();
 498    if (hFile != INVALID_HANDLE_VALUE)
 499       FindClose(hFile);
 500    if (dwError != ERROR_NO_MORE_FILES)
 501    {
 502       LPVOID lpMsgBuf;
 503       FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER|
 504                     FORMAT_MESSAGE_FROM_SYSTEM|
 505                     FORMAT_MESSAGE_IGNORE_INSERTS,
 506                     NULL,GetLastError(),
 507                     MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language
 508                     (LPTSTR) &lpMsgBuf,0,NULL);
 509
 510      // ErrorMacro("FindNextFile error. Error is " << (char *)lpMsgBuf
 511      //             <<" for the directory : "<<dirName);
 512
 513       return 0;
 514    }
 515
 516 #else
 517   // Real POSIX implementation: scandir is a BSD extension only, and doesn't
 518   // work on debian for example
 519 //std::cout <<"in Explor dirname[" << dirName << "]" << std::endl;
 520    DIR* dir = opendir(dirName.c_str());
 521    if (!dir)
 522    {
 523       return 0;
 524    }
 525 //std::cout <<"Open OK" << std::endl;
 526    // According to POSIX, the dirent structure contains a field char d_name[]
 527    // of unspecified size, with at most NAME_MAX characters preceeding the
 528    // terminating null character. Use of other fields will harm the  porta-
 529    // bility of your programs.
 530
 531    struct stat buf;
 532    dirent *d;
 533    for (d = readdir(dir); d; d = readdir(dir))
 534    {
 535       fileName = dirName + "/" + d->d_name;
 536 //std::cout <<"in Explor filename[" << fileName << "]" << std::endl;
 537       if( stat(fileName.c_str(), &buf) != 0 )
 538       {
 539          //ErrorMacro( strerror(errno) );
 540       }
 541       if ( S_ISREG(buf.st_mode) )    //is it a regular file?
 542       {
 543          Filenames.push_back( fileName );
 544          numberOfFiles++;
 545       }
 546       else if ( S_ISDIR(buf.st_mode) ) //directory?
 547       {
 548          if ( d->d_name[0] != '.' && recursive ) //we also skip hidden files
 549          {
 550             numberOfFiles += Explore( fileName, recursive, Filenames);
 551          }
 552       }
 553       else
 554       {
 555          //ErrorMacro( "Unexpected error" );
 556          return -1;
 557       }
 558    }
 559    if( closedir(dir) != 0 )
 560    {
 561      // ErrorMacro( strerror(errno) );
 562    }
 563 #endif
 564
 565   return numberOfFiles;
 566
 567 }
 568   //=======================================================================
 569
 570
 571     //=======================================================================
 572     // Replaces substrings "\\n" by a real carriage return "\n"
 573     void Utilities::SubsBackslashN ( std::string& s )
 574     {
 575       std::string ss("\\n");
 576       std::string::size_type pos = 0;
 577       pos = s.find(ss,0);
 578       const char* cr = "\n";
 579       while ( pos != std::string::npos )
 580         {
 581           s.replace(pos,2,cr,1);
 582           pos = s.find(ss, pos-1);
 583         }
 584     }
 585     //=======================================================================
 586
 587
 588    //=======================================================================
 589
 590   bool Utilities::loosematch(std::string stdLine,std::string stdOptions)
 591   {
 592     bool result=false;
 593     std::vector<std::string> tokens;
 594     SplitString ( stdOptions,"|", tokens);
 595     int i,size=tokens.size();
 596     for (i=0; i<size; i++)
 597       {
 598 #ifdef WIN32
 599         if ( strcmpi(stdLine.c_str(),tokens[i].c_str())==0)
 600           {
 601             result=true;
 602           }
 603 #else
 604         if ( strcasecmp(stdLine.c_str(),tokens[i].c_str())==0)
 605           {
 606             result=true;
 607           }
 608 #endif
 609
 610       }
 611     return result;
 612   }
 613   //=========================================================================
 614
 615   //=========================================================================
 616   // From http://www.fltk.org/newsgroups.php?gfltk.general+v:22083
 617   //
 618   int get_app_path (char *pname, size_t pathsize)
 619   {
 620 #ifdef LINUX
 621     /* Oddly, the readlink(2) man page says no NULL is appended. */
 622     /* So you have to do it yourself, based on the return value: */
 623     pathsize --; /* Preserve a space to add the trailing NULL */
 624     long result = readlink("/proc/self/exe", pname, pathsize);
 625     if (result > 0)
 626       {
 627         pname[result] = 0; /* add the #@!%ing NULL */
 628
 629         if ((access(pname, 0) == 0))
 630           return 0; /* file exists, return OK */
 631         /*else name doesn't seem to exist, return FAIL (falls
 632           through) */
 633       }
 634 #endif /* LINUX */
 635
 636 #ifdef WIN32
 637     long result = GetModuleFileName(NULL, pname, pathsize);
 638     if (result > 0)
 639       {
 640         /* fix up the dir slashes... */
 641         int len = strlen(pname);
 642         int idx;
 643         for (idx = 0; idx < len; idx++)
 644           {
 645             if (pname[idx] == '\\') pname[idx] = '/';
 646           }
 647
 648         for (idx = len-1; idx >=0 ; idx--)
 649           {
 650             if (pname[idx] == '/')
 651               {
 652                 pname[idx+1] = '\0';
 653                 idx = -1;
 654               }
 655           }
 656
 657         if ((access(pname, 0) == 0))
 658           return 0; /* file exists, return OK */
 659         /*else name doesn't seem to exist, return FAIL (falls
 660           through) */
 661       }
 662 #endif /* WIN32 */
 663
 664 #ifdef SOLARIS
 665     char *p = getexecname();
 666     if (p)
 667       {
 668         /* According to the Sun manpages, getexecname will
 669            "normally" return an */
 670         /* absolute path - BUT might not... AND that IF it is not,
 671            pre-pending */
 672         /* getcwd() will "usually" be the correct thing... Urgh!
 673          */
 674
 675         /* check pathname is absolute (begins with a / ???) */
 676         if (p[0] == '/') /* assume this means we have an
 677                             absolute path */
 678           {
 679             strncpy(pname, p, pathsize);
 680             if ((access(pname, 0) == 0))
 681               return 0; /* file exists, return OK */
 682           }
 683         else /* if not, prepend getcwd() then check if file
 684                 exists */
 685           {
 686             getcwd(pname, pathsize);
 687             long result = strlen(pname);
 688             strncat(pname, "/", (pathsize - result));
 689             result ++;
 690             strncat(pname, p, (pathsize - result));
 691
 692             if ((access(pname, 0) == 0))
 693               return 0; /* file exists, return OK */
 694             /*else name doesn't seem to exist, return FAIL
 695               (falls through) */
 696           }
 697       }
 698 #endif /* SOLARIS */
 699
 700 #ifdef MACOSX /* assume this is OSX */
 701     /*
 702       from http://www.hmug.org/man/3/NSModule.html
 703
 704       extern int _NSGetExecutablePath(char *buf, unsigned long
 705       *bufsize);
 706
 707       _NSGetExecutablePath  copies  the  path  of the executable
 708       into the buffer and returns 0 if the path was successfully
 709       copied  in the provided buffer. If the buffer is not large
 710       enough, -1 is returned and the  expected  buffer  size  is
 711       copied  in  *bufsize.  Note that _NSGetExecutablePath will
 712       return "a path" to the executable not a "real path" to the
 713       executable.  That  is  the path may be a symbolic link and
 714       not the real file. And with  deep  directories  the  total
 715       bufsize needed could be more than MAXPATHLEN.
 716     */
 717     int status = -1;
 718     char *given_path = (char*)malloc(MAXPATHLEN * 2);
 719     if (!given_path) return status;
 720
 721     uint32_t npathsize = MAXPATHLEN * 2;
 722     long result = _NSGetExecutablePath(given_path, &npathsize);
 723     if (result == 0)
 724       { /* OK, we got something - now try and resolve the real path...
 725          */
 726         if (realpath(given_path, pname) != NULL)
 727           {
 728             if ((access(pname, 0) == 0))
 729               status = 0; /* file exists, return OK */
 730           }
 731       }
 732     free (given_path);
 733     return status;
 734 #endif /* MACOSX */
 735
 736     return -1; /* Path Lookup Failed */
 737   }
 738   //=========================================================================
 739
 740
 741
 742   //=========================================================================
 743   std::string Utilities::GetExecutablePath()
 744   {
 745     char name[PATH_MAX];
 746     int err = get_app_path(name, PATH_MAX);
 747     if (err)
 748       {
 749         bbtkGlobalError("Could not determine current executable path ?");
 750       }
 751
 752     // remove the exe name
 753     char *slash;
 754     slash = strrchr(name, VALID_FILE_SEPARATOR_CHAR);
 755     if (slash)
 756       {
 757         *slash = 0;
 758       }
 759     return name;
 760   }
 761   //=========================================================================
 762
 763
 764
 765 }