kernel/src/bbtkUtilities.cxx

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