PathResolver.cxx

Go to the documentation of this file.

 
 
#include "HltTools/PathResolver.h"
 
#include <cstdio>
#include <cstdlib>
 
#include <iostream>
#include <string.h>
#include <vector>
 
#include <sys/stat.h>
 
#ifdef WIN32
#  define stat _stat
#  include <direct.h>
#else
#  include <dirent.h>
#  include <unistd.h>
#endif
 
typedef enum { PR_regular_file, PR_directory } PR_file_type;
 
typedef enum { PR_local, PR_recursive } PR_search_type;
 
static void PR_compress_path( std::string& dir ) {
#ifdef WIN32
  static const char pattern[] = "\\..\\";
#else
  static const char pattern[] = "/../";
#endif
 
#ifdef WIN32
  static const char file_separator          = '\\';
  static const char double_file_separator[] = "\\\\";
#else
  static const char file_separator          = '/';
  static const char double_file_separator[] = "//";
#endif
 
  if ( dir.size() == 0 ) return;
 
  //
  // We first synchronize to using file_separator() in any case.
  //
 
  for ( ;; )
  {
    std::string::size_type pos;
    pos = dir.find( double_file_separator );
    if ( pos == std::string::npos ) break;
    dir.erase( pos, 1 );
  }
 
  for ( ;; )
  {
    std::string::size_type pos1;
    std::string::size_type pos2;
 
    pos1 = dir.find( pattern );
    if ( pos1 == std::string::npos ) break;
 
    //
    // extract "aaaa/xxxx" from "aaaa/xxxx/../bbbb"
    //
    std::string p = dir.substr( 0, pos1 );
 
    //
    // Is "aaaa/xxxx" only made of "xxxx" ?
    //
    pos2 = p.find_last_of( file_separator );
 
    if ( pos2 == std::string::npos ) break;
 
    //    01234567890123456
    //    aaaa/xxxx/../bbbb
    //        2    1   3
    //
    // erase the "/xxxx/../" pattern
    // result will be "aaaa/bbbb"
    //
    dir.erase( pos2, pos1 + 4 - pos2 - 1 );
  }
 
  // if (dir[dir.size () - 1] == file_separator ()) dir.erase (dir.size () - 1);
}
 
static void PR_dirname( const std::string& file_name, std::string& result ) {
  std::string::size_type pos = file_name.find_last_of( '/' );
  if ( pos == std::string::npos ) { pos = file_name.find_last_of( '\\' ); }
 
  if ( pos == std::string::npos ) { result = ""; }
  else
  {
    result = file_name;
    result.erase( pos );
  }
}
 
static bool PR_absolute_path( const std::string& name ) {
  if ( name.size() == 0 ) return ( false );
 
  if ( ( name[0] == '/' ) || ( name[0] == '\\' ) ) return ( true );
 
  if ( name.size() >= 2 )
  {
    if ( name[1] == ':' ) { return ( true ); }
  }
  return ( false );
}
 
static void PR_basename( const std::string& file_name, std::string& result ) {
  std::string::size_type pos = file_name.find_last_of( '/' );
 
  if ( pos == std::string::npos ) { pos = file_name.find_last_of( '\\' ); }
 
  if ( pos == std::string::npos ) { result = file_name; }
  else { result = file_name.substr( pos + 1 ); }
}
 
static bool PR_test_exist( const std::string& name, std::string& real_name,
                           PR_file_type file_type ) {
  struct stat file_stat;
  int         status;
 
  char buf[1024];
 
  strcpy( buf, name.c_str() );
 
#ifdef WIN32
  static const char file_separator = '\\';
#else
  static const char file_separator = '/';
#endif
 
  real_name = name;
 
  // std::cout << "test_file> name=" << name << std::endl;
 
  for ( ;; )
  {
    status = lstat( buf, &file_stat );
 
    if ( status == 0 )
    {
      if ( S_ISLNK( file_stat.st_mode ) != 0 )
      {
        // std::cout << "#1 " << buf << " stat=" << std::oct << file_stat.st_mode << std::dec
        // << std::endl;
 
        int n = readlink( buf, buf, sizeof( buf ) );
        if ( n >= 0 ) buf[n] = 0;
 
        // std::cout << "test_exist> buf=" << buf << std::endl;
 
        if ( PR_absolute_path( buf ) ) { real_name = buf; }
        else
        {
          PR_dirname( real_name, real_name );
          real_name += file_separator;
          real_name += buf;
 
          PR_compress_path( real_name );
 
          strcpy( buf, real_name.c_str() );
        }
 
        // std::cout << "#2 " << real_name << std::endl;
 
        // break;
      }
      else { break; }
    }
    else { break; }
  }
 
  status = stat( name.c_str(), &file_stat );
 
  if ( status == 0 )
  {
    if ( ( file_stat.st_mode & S_IFDIR ) == 0 ) { return ( file_type == PR_regular_file ); }
    else { return ( file_type == PR_directory ); }
  }
  else { return ( false ); }
}
 
static void PR_scan_dir( const std::string& dir_name, std::vector<std::string>& list ) {
#ifdef WIN32
  static const char file_separator = '\\';
#else
  static const char file_separator = '/';
#endif
 
  static std::string dir_prefix;
  static std::string name_prefix;
  static std::string real_name;
 
  dir_prefix = dir_name;
  if ( dir_name == "" ) dir_prefix = ".";
 
  // std::cout << "PR_scan_dir1> dir_name=" << dir_name << " dir_prefix=" << dir_prefix <<
  // std::endl;
 
  if ( !PR_test_exist( dir_prefix, real_name, PR_directory ) )
  {
    PR_dirname( dir_prefix, dir_prefix );
    PR_basename( dir_name, name_prefix );
  }
 
  bool need_filter = false;
 
  std::string::size_type wild_card;
  // unsigned int wild_card;
 
  wild_card = name_prefix.find( '*' );
  if ( wild_card != std::string::npos )
  {
    name_prefix.erase( wild_card );
 
    if ( name_prefix.size() > 0 ) { need_filter = true; }
  }
 
  list.clear();
 
#ifdef WIN32
 
  long               dir;
  struct _finddata_t entry;
 
  static std::string search;
 
  search = dir_prefix;
  search += file_separator;
  search += "*";
 
  dir = _findfirst( search.c_str(), &entry );
  if ( dir > 0 )
  {
    for ( ;; )
    {
      if ( ( strcmp( (char*)entry.name, "." ) != 0 ) &&
           ( strcmp( (char*)entry.name, ".." ) != 0 ) &&
           ( strncmp( (char*)entry.name, ".nfs", 4 ) != 0 ) )
      {
        const char* name = entry.name;
 
        if ( !need_filter ||
             ( strncmp( name, name_prefix.c_str(), name_prefix.size() ) == 0 ) )
        {
          std::string& name_entry = list.add();
 
          name_entry = dir_prefix;
          name_entry += file_separator;
          name_entry += name;
        }
      }
 
      int status = _findnext( dir, &entry );
      if ( status != 0 ) { break; }
    }
 
    _findclose( dir );
  }
#else
 
  // std::cout << "scan_dir2> dir_prefix=" << dir_prefix << std::endl;
 
  DIR* dir = opendir( dir_prefix.c_str() );
 
  struct dirent* entry;
 
  if ( dir != 0 )
  {
 
    // std::cout << "scan_dir3> need_filter=" << need_filter << std::endl;
 
    while ( ( entry = readdir( dir ) ) != 0 )
    {
      // if (entry->d_name[0] == '.') continue;
      if ( !strcmp( (char*)entry->d_name, "." ) ) continue;
      if ( !strcmp( (char*)entry->d_name, ".." ) ) continue;
      if ( !strncmp( (char*)entry->d_name, ".nfs", 4 ) ) continue;
 
      const char* name = entry->d_name;
 
      // std::cout << "scan_dir4> name=" << name << std::endl;
 
      if ( need_filter && ( strncmp( name, name_prefix.c_str(), name_prefix.size() ) != 0 ) )
        continue;
 
      std::string name_entry;
 
      name_entry = dir_prefix;
      name_entry += file_separator;
      name_entry += name;
 
      list.push_back( name_entry );
    }
 
    closedir( dir );
  }
#endif
}
 
static void PR_indent( int level ) {
  while ( level > 0 )
  {
    std::cout << "  ";
    level--;
  }
}
 
static bool PR_find( const std::string& search_base, const std::string& logical_file_prefix,
                     const std::string& logical_file_name, PR_file_type file_type,
                     PathResolver::SearchType search_type, std::string& result ) {
  static int level = 0;
 
#ifdef WIN32
  static const char file_separator = '\\';
#else
  static const char file_separator = '/';
#endif
 
  std::string file_path = "";
  std::string real_name = "";
 
  bool found = false;
 
  // PR_indent (level); std::cout << "PR_find> sb=" << search_base << " lfp=" <<
  // logical_file_prefix << " lfn=" << logical_file_name << std::endl;
 
  if ( search_base != "" )
  {
    file_path = search_base;
    file_path += file_separator;
  }
  else { file_path = ""; }
 
  file_path += logical_file_name;
 
  // PR_indent (level); std::cout << "PR_find> test1 file_path=" << file_path << std::endl;
 
  result = file_path;
  if ( PR_test_exist( file_path, result, file_type ) ) { found = true; }
 
  if ( !found && ( logical_file_prefix != "" ) )
  {
    if ( search_base != "" )
    {
      file_path = search_base;
      file_path += file_separator;
    }
    else { file_path = ""; }
 
    file_path += logical_file_prefix;
    file_path += file_separator;
    file_path += logical_file_name;
 
    // PR_indent (level); std::cout << "PR_find> test2 file_path=" << file_path << std::endl;
 
    result = file_path;
    if ( PR_test_exist( file_path, result, file_type ) ) { found = true; }
  }
 
  // PR_indent (level); std::cout << "PR_find> test3 found=" << found << " search_type=" <<
  // search_type << std::endl;
 
  if ( !found && ( search_type == PathResolver::RecursiveSearch ) )
  {
    std::string              dir_name  = "";
    std::string              file_name = "";
    std::vector<std::string> list;
 
    PR_scan_dir( search_base, list );
 
    std::vector<std::string>::iterator it;
 
    for ( it = list.begin(); it != list.end(); ++it )
    {
      const std::string& d = *it;
 
      if ( PR_test_exist( d, file_path, PR_directory ) )
      {
        // PR_indent (level); std::cout << "d=" << d << std::endl;
 
        level++;
        bool s = PR_find( d, logical_file_prefix, logical_file_name, file_type, search_type,
                          result );
        level--;
 
        if ( s )
        {
          // PR_indent (level); std::cout << "PR_find> result=" << result << std::endl;
          found = true;
          break;
        }
      }
    }
  }
 
  return ( found );
}
 
static bool PR_find_from_list( const std::string& logical_file_name,
                               const std::string& search_list, PR_file_type file_type,
                               PathResolver::SearchType search_type, std::string& result ) {
#ifdef WIN32
  static const char path_separator = ';';
#else
  static const char path_separator = ':';
#endif
 
  std::string::size_type pos = 0;
 
  std::string file_name   = "";
  std::string file_prefix = "";
 
  PR_basename( logical_file_name, file_name );
  PR_dirname( logical_file_name, file_prefix );
 
  std::string real_name = "";
 
  bool found = false;
 
  if ( PR_find( "", file_prefix, file_name, file_type, search_type, result ) )
  { found = true; }
 
  if ( !found )
  {
    for ( int i = 0;; i++ )
    {
      bool ending = false;
 
      std::string::size_type next = search_list.find( path_separator, pos );
 
      std::string path = search_list.substr( pos, next - pos );
 
      if ( next == std::string::npos )
      {
        path   = search_list.substr( pos );
        ending = true;
      }
      else
      {
        path = search_list.substr( pos, next - pos );
        pos  = next + 1;
      }
 
      // std::cout << "path[" << i << "]=" << path << std::endl;
 
      if ( PR_find( path, file_prefix, file_name, file_type, search_type, result ) )
      {
        found = true;
        break;
      }
 
      if ( ending ) break;
    }
  }
 
  return ( found );
}
 
std::string PathResolver::find_file( const std::string& logical_file_name,
                                     const std::string& search_path, SearchType search_type ) {
  const char* path_env = ::getenv( search_path.c_str() );
 
  std::string path_list;
 
  if ( path_env != 0 ) { path_list = path_env; }
 
  return ( find_file_from_list( logical_file_name, path_list, search_type ) );
}
 
std::string PathResolver::find_file_from_list( const std::string& logical_file_name,
                                               const std::string& search_list,
                                               SearchType         search_type ) {
  std::string result;
 
  if ( !PR_find_from_list( logical_file_name, search_list, PR_regular_file, search_type,
                           result ) )
  { result = ""; }
 
  return ( result );
}
 
std::string PathResolver::find_directory( const std::string& logical_file_name,
                                          const std::string& search_path,
                                          SearchType         search_type ) {
  const char* path_env = ::getenv( search_path.c_str() );
 
  std::string path_list;
 
  if ( path_env != 0 ) { path_list = path_env; }
 
  return ( find_directory_from_list( logical_file_name, path_list, search_type ) );
}
 
std::string PathResolver::find_directory_from_list( const std::string& logical_file_name,
                                                    const std::string& search_list,
                                                    SearchType         search_type ) {
  std::string result;
 
  if ( !PR_find_from_list( logical_file_name, search_list, PR_directory, search_type,
                           result ) )
  { result = ""; }
 
  return ( result );
}
 
PathResolver::SearchPathStatus
PathResolver::check_search_path( const std::string& search_path ) {
  const char* path_env = ::getenv( search_path.c_str() );
 
  if ( path_env == 0 ) return ( EnvironmentVariableUndefined );
 
#ifdef WIN32
  static const char path_separator = ';';
#else
  static const char path_separator = ':';
#endif
 
  std::string path_list( path_env );
 
  std::string::size_type pos = 0;
 
  for ( int i = 0;; i++ )
  {
    bool ending = false;
 
    std::string::size_type next = path_list.find( path_separator, pos );
 
    std::string path = path_list.substr( pos, next - pos );
 
    if ( next == std::string::npos )
    {
      path   = path_list.substr( pos );
      ending = true;
    }
    else
    {
      path = path_list.substr( pos, next - pos );
      pos  = next + 1;
    }
 
    std::string real_name = "";
 
    if ( !PR_test_exist( path, real_name, PR_directory ) ) { return ( UnknownDirectory ); }
 
    if ( ending ) break;
  }
 
  return ( Ok );
}
 
extern "C" {
PathResolver::SearchPathStatus PathResolverCheckSearchPath( const std::string& search_path ) {
  return PathResolver::check_search_path( search_path );
}
 
std::string PathResolverFindDirectory( const std::string& logical_file_name,
                                       const std::string& search_path ) {
  return PathResolver::find_directory( logical_file_name, search_path );
}
 
std::string PathResolverFindDirectoryFromList( const std::string& logical_file_name,
                                               const std::string& search_list ) {
  return PathResolver::find_directory_from_list( logical_file_name, search_list );
}
 
std::string PathResolverFindFile( const std::string& logical_file_name,
                                  const std::string& search_path ) {
  return PathResolver::find_file( logical_file_name, search_path );
}
 
std::string PathResolverFindFileFromList( const std::string& logical_file_name,
                                          const std::string& search_list ) {
  return PathResolver::find_file_from_list( logical_file_name, search_list );
}
 
std::string PathResolverFindXMLFile( const std::string& logical_file_name ) {
  return PathResolver::find_file( logical_file_name, "XMLPATH" );
}
 
std::string PathResolverFindDataFile( const std::string& logical_file_name ) {
  return PathResolver::find_file( logical_file_name, "DATAPATH" );
}
}