开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数值算法/人工智能 > 生物技术 > 查看源码
ncbifile.cpp
资源名称：ncbi_cxx_win--Jul_08_2004.zip　[点击查看]
上传用户：yhdzpy8989
上传日期：2007-06-13
资源大小：13604k
文件大小：62k
源码类别：

生物技术

开发平台：

C/C++

ncbifile.cpp：源码内容
  1. /*
  2.  * ===========================================================================
  3.  * PRODUCTION $Log: ncbifile.cpp,v $
  4.  * PRODUCTION Revision 1000.5  2004/06/01 19:09:09  gouriano
  5.  * PRODUCTION PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.78
  6.  * PRODUCTION
  7.  * ===========================================================================
  8.  */
  10. /*  $Id: ncbifile.cpp,v 1000.5 2004/06/01 19:09:09 gouriano Exp $
  11.  * ===========================================================================
  12.  *
  13.  *                            PUBLIC DOMAIN NOTICE
  14.  *               National Center for Biotechnology Information
  15.  *
  16.  *  This software/database is a "United States Government Work" under the
  17.  *  terms of the United States Copyright Act.  It was written as part of
  18.  *  the author's official duties as a United States Government employee and
  19.  *  thus cannot be copyrighted.  This software/database is freely available
  20.  *  to the public for use. The National Library of Medicine and the U.S.
  21.  *  Government have not placed any restriction on its use or reproduction.
  22.  *
  23.  *  Although all reasonable efforts have been taken to ensure the accuracy
  24.  *  and reliability of the software and data, the NLM and the U.S.
  25.  *  Government do not and cannot warrant the performance or results that
  26.  *  may be obtained by using this software or data. The NLM and the U.S.
  27.  *  Government disclaim all warranties, express or implied, including
  28.  *  warranties of performance, merchantability or fitness for any particular
  29.  *  purpose.
  30.  *
  31.  *  Please cite the author in any work or product based on this material.
  32.  *
  33.  * ===========================================================================
  34.  *
  35.  * Author: Vladimir Ivanov
  36.  *
  37.  * File Description:   Files and directories accessory functions
  38.  *
  39.  */
  41. #include <ncbi_pch.hpp>
  42. #include <corelib/ncbifile.hpp>
  44. #if !defined(NCBI_OS_MAC)
  45. #  include <sys/types.h>
  46. #  if defined(HAVE_SYS_STAT_H)
  47. #    include <sys/stat.h>
  48. #  endif
  49. #endif
  51. #include <stdio.h>
  53. #if defined(NCBI_OS_MSWIN)
  54. #  include <corelib/ncbi_os_mswin.hpp>
  55. #  include <corelib/ncbi_limits.hpp>
  56. #  include <io.h>
  57. #  include <direct.h>
  58. #  include <sys/utime.h>
  60. #elif defined(NCBI_OS_UNIX)
  61. #  include <unistd.h>
  62. #  include <dirent.h>
  63. #  include <pwd.h>
  64. #  include <fcntl.h>
  65. #  include <sys/mman.h>
  66. #  include <utime.h>
  67. #  if !defined(MAP_FAILED)
  68. #    define MAP_FAILED ((void *) -1)
  69. #  endif
  71. #  if defined(NCBI_COMPILER_MW_MSL)
  72. #    include <ncbi_mslextras.h>
  73. #  endif
  75. #elif defined(NCBI_OS_MAC)
  76. #  include <fcntl.h>
  77. #  include <corelib/ncbi_os_mac.hpp>
  78. #  include <Script.h>
  79. #  include <Gestalt.h>
  80. #  include <Folders.h>
  82. #endif  /* NCBI_OS_MSWIN, NCBI_OS_UNIX, NCBI_OS_MAC */
  85. BEGIN_NCBI_SCOPE
  88. // Path separators
  90. #undef  DIR_SEPARATOR
  91. #undef  DIR_SEPARATOR_ALT
  92. #undef  DIR_SEPARATORS
  93. #undef  DISK_SEPARATOR
  94. #undef  ALL_SEPARATORS
  95. #undef  ALL_OS_SEPARATORS
  97. #define DIR_PARENT  ".."
  98. #define DIR_CURRENT "."
  99. #define ALL_OS_SEPARATORS   ":/\"
  101. #if defined(NCBI_OS_MSWIN)
  102. #  define DIR_SEPARATOR     '\'
  103. #  define DIR_SEPARATOR_ALT '/'
  104. #  define DISK_SEPARATOR    ':'
  105. #  define DIR_SEPARATORS    "/\"
  106. #  define ALL_SEPARATORS    ":/\"
  108. #elif defined(NCBI_OS_UNIX)
  109. #  define DIR_SEPARATOR     '/'
  110. #  define DIR_SEPARATORS    "/"
  111. #  define ALL_SEPARATORS    "/"
  113. #elif defined(NCBI_OS_MAC)
  114. #  define DIR_SEPARATOR     ':'
  115. #  define DIR_SEPARATORS    ':'
  116. #  define ALL_SEPARATORS    ":"
  117. #  undef  DIR_PARENT
  118. #  undef  DIR_CURRENT
  119. #endif
  122. //////////////////////////////////////////////////////////////////////////////
  123. //
  124. // Static functions
  125. //
  127. #if defined(NCBI_OS_MAC)
  128. static const FSSpec sNullFSS = {0, 0, "p"};
  130. static bool operator== (const FSSpec& one, const FSSpec& other)
  131. {
  132.     return one.vRefNum == other.vRefNum
  133.         && one.parID   == other.parID
  134.         && PString(one.name) == PString(other.name);
  135. }
  136. #endif  /* NCBI_OS_MAC */
  139. // Construct real entry mode from parts. Parameters can not have "fDefault" 
  140. // value.
  141. static CDirEntry::TMode s_ConstructMode(CDirEntry::TMode user_mode, 
  142.                                         CDirEntry::TMode group_mode, 
  143.                                         CDirEntry::TMode other_mode)
  144. {
  145.     CDirEntry::TMode mode = 0;
  146.     mode |= (user_mode  << 6);
  147.     mode |= (group_mode << 3);
  148.     mode |= other_mode;
  149.     return mode;
  150. }
  153. //////////////////////////////////////////////////////////////////////////////
  154. //
  155. // CDirEntry
  156. //
  159. CDirEntry::CDirEntry()
  160. #if defined(NCBI_OS_MAC)
  161.     : m_FSS(new FSSpec(sNullFSS))
  162. #endif
  163. {
  164. }
  166. #if defined(NCBI_OS_MAC)
  167. CDirEntry::CDirEntry(const CDirEntry& other) : m_FSS(new FSSpec(*other.m_FSS))
  168. {
  169.     m_DefaultMode[eUser]  = other.m_DefaultMode[eUser];
  170.     m_DefaultMode[eGroup] = other.m_DefaultMode[eGroup];
  171.     m_DefaultMode[eOther] = other.m_DefaultMode[eOther];
  172. }
  175. CDirEntry&
  176. CDirEntry::operator= (const CDirEntry& other)
  177. {
  178.     *m_FSS = *other.m_FSS;
  179.     m_DefaultMode[eUser]  = other.m_DefaultMode[eUser];
  180.     m_DefaultMode[eGroup] = other.m_DefaultMode[eGroup];
  181.     m_DefaultMode[eOther] = other.m_DefaultMode[eOther];
  182.     return *this;
  183. }
  186. CDirEntry::CDirEntry(const FSSpec& fss) : m_FSS(new FSSpec(fss))
  187. {
  188.     m_DefaultMode[eUser]  = m_DefaultModeGlobal[eFile][eUser];
  189.     m_DefaultMode[eGroup] = m_DefaultModeGlobal[eFile][eGroup];
  190.     m_DefaultMode[eOther] = m_DefaultModeGlobal[eFile][eOther];
  191. }
  192. #endif
  195. CDirEntry::CDirEntry(const string& name)
  196. #if defined(NCBI_OS_MAC)
  197.     : m_FSS(new FSSpec(sNullFSS))
  198. #endif
  199. {
  200.     Reset(name);
  201.     m_DefaultMode[eUser]  = m_DefaultModeGlobal[eFile][eUser];
  202.     m_DefaultMode[eGroup] = m_DefaultModeGlobal[eFile][eGroup];
  203.     m_DefaultMode[eOther] = m_DefaultModeGlobal[eFile][eOther];
  204. }
  207. #if defined(NCBI_OS_MAC)
  208. bool CDirEntry::operator== (const CDirEntry& other) const
  209. {
  210.     return *m_FSS == *other.m_FSS;
  211. }
  213. const FSSpec& CDirEntry::FSS() const
  214. {
  215.     return *m_FSS;
  216. }
  217. #endif
  221. CDirEntry::TMode CDirEntry::m_DefaultModeGlobal[eUnknown][3] =
  222. {
  223.     // eFile
  224.     { CDirEntry::fDefaultUser, CDirEntry::fDefaultGroup, 
  225.           CDirEntry::fDefaultOther },
  226.     // eDir
  227.     { CDirEntry::fDefaultDirUser, CDirEntry::fDefaultDirGroup, 
  228.           CDirEntry::fDefaultDirOther },
  229.     // ePipe
  230.     { CDirEntry::fDefaultUser, CDirEntry::fDefaultGroup, 
  231.           CDirEntry::fDefaultOther },
  232.     // eLink
  233.     { CDirEntry::fDefaultUser, CDirEntry::fDefaultGroup, 
  234.           CDirEntry::fDefaultOther },
  235.     // eSocket
  236.     { CDirEntry::fDefaultUser, CDirEntry::fDefaultGroup, 
  237.           CDirEntry::fDefaultOther },
  238.     // eDoor
  239.     { CDirEntry::fDefaultUser, CDirEntry::fDefaultGroup, 
  240.           CDirEntry::fDefaultOther },
  241.     // eBlockSpecial
  242.     { CDirEntry::fDefaultUser, CDirEntry::fDefaultGroup, 
  243.           CDirEntry::fDefaultOther },
  244.     // eCharSpecial
  245.     { CDirEntry::fDefaultUser, CDirEntry::fDefaultGroup, 
  246.           CDirEntry::fDefaultOther }
  247. };
  251. #if defined(NCBI_OS_MAC)
  252. void CDirEntry::Reset(const string& path)
  253. {
  254.     OSErr err = MacPathname2FSSpec(path.c_str(), m_FSS);
  255.     if (err != noErr  &&  err != fnfErr) {
  256.         *m_FSS = sNullFSS;
  257.     }
  258. }
  260. string CDirEntry::GetPath(void) const
  261. {
  262.     OSErr err;
  263.     char* path;
  264.     err = MacFSSpec2FullPathname(&FSS(), &path);
  265.     if (err != noErr) {
  266.         return kEmptyStr;
  267.     }
  268.     return string(path);
  269. }
  270. #endif
  273. CDirEntry::~CDirEntry(void)
  274. {
  275. #if defined(NCBI_OS_MAC)
  276.     delete m_FSS;
  277. #endif
  278. }
  281. void CDirEntry::SplitPath(const string& path, string* dir,
  282.                           string* base, string* ext)
  283. {
  284.     // Get file name
  285.     size_t pos = path.find_last_of(ALL_SEPARATORS);
  286.     string filename = (pos == NPOS) ? path : path.substr(pos+1);
  288.     // Get dir
  289.     if ( dir ) {
  290.         *dir = (pos == NPOS) ? kEmptyStr : path.substr(0, pos+1);
  291.     }
  292.     // Split file name to base and extension
  293.     pos = filename.rfind('.');
  294.     if ( base ) {
  295.         *base = (pos == NPOS) ? filename : filename.substr(0, pos);
  296.     }
  297.     if ( ext ) {
  298.         *ext = (pos == NPOS) ? kEmptyStr : filename.substr(pos);
  299.     }
  300. }
  303. string CDirEntry::MakePath(const string& dir, const string& base, 
  304.                            const string& ext)
  305. {
  306.     string path;
  308.     // Adding "dir" and file base
  309.     if ( dir.length() ) {
  310.         path = AddTrailingPathSeparator(dir);
  311.     }
  312.     path += base;
  313.     // Adding extension
  314.     if ( ext.length()  &&  ext.at(0) != '.' ) {
  315.         path += '.';
  316.     }
  317.     path += ext;
  318.     // Return result
  319.     return path;
  320. }
  323. char CDirEntry::GetPathSeparator(void) 
  324. {
  325.     return DIR_SEPARATOR;
  326. }
  329. bool CDirEntry::IsPathSeparator(const char c)
  330. {
  331. #if defined(DISK_SEPARATOR)
  332.     if ( c == DISK_SEPARATOR ) {
  333.         return true;
  334.     }
  335. #endif
  336. #if defined(DIR_SEPARATOR_ALT)
  337.     if ( c == DIR_SEPARATOR_ALT ) {
  338.         return true;
  339.     }
  340. #endif
  341.     return c == DIR_SEPARATOR;
  342. }
  345. string CDirEntry::AddTrailingPathSeparator(const string& path)
  346. {
  347.     size_t len = path.length();
  348. #if defined(NCBI_OS_MAC)
  349.     if ( !len ) {
  350.         return string(1,GetPathSeparator());
  351.     }
  352. #endif
  353.     if (len  &&  string(ALL_SEPARATORS).rfind(path.at(len - 1)) == NPOS) {
  354.         return path + GetPathSeparator();
  355.     }
  356.     return path;
  357. }
  360. string CDirEntry::DeleteTrailingPathSeparator(const string& path)
  361. {
  362.     size_t pos = path.find_last_not_of(DIR_SEPARATORS);
  363.     if (pos + 1 < path.length()) {
  364.         return path.substr(0, pos + 1);
  365.     }
  366.     return path;
  367. }
  370. bool CDirEntry::IsAbsolutePath(const string& path)
  371. {
  372.     if ( path.empty() )
  373.         return false;
  374.     char first = path[0];
  376. #if defined(NCBI_OS_MAC)
  377.     if ( path.find(DIR_SEPARATOR) != NPOS  &&  first != DIR_SEPARATOR )
  378.         return true;
  379. #else
  380.     if ( IsPathSeparator(first) )
  381.         return true;
  382. #endif
  383. #if defined(DISK_SEPARATOR)
  384.     if ( path.find(DISK_SEPARATOR) != NPOS )
  385.         return true;
  386. #endif
  387.     return false;
  388. }
  391. bool CDirEntry::IsAbsolutePathEx(const string& path)
  392. {
  393.     if ( path.empty() )
  394.         return false;
  395.     char first = path[0];
  397.     // MAC or WIN absolute
  398.     if ( path.find(':') != NPOS  &&  first != ':' )
  399.         return true;
  401.     // MAC relative path
  402.     if ( first == ':' )
  403.         return false;
  405.     // UNIX or WIN absolute
  406.     if ( first == '\' || first == '/' )
  407.         return true;
  409.     // Else - relative
  410.     return false;
  411. }
  414. /// Helper : strips dir to parts:
  415. ///     c:ab     will be <c:><a><b>
  416. ///     /usr/bin/   will be </><usr><bin>
  417. static void s_StripDir(const string& dir, vector<string> * dir_parts)
  418. {
  419.     dir_parts->clear();
  420.     if ( dir.empty() ) 
  421.         return;
  423.     const char sep = CDirEntry::GetPathSeparator();
  425.     size_t sep_pos = 0;
  426.     size_t last_ind = dir.length() - 1;
  427.     size_t part_start = 0;
  428.     for (;;) {
  429.         sep_pos = dir.find(sep, sep_pos);
  430.         if (sep_pos == NPOS) {
  431.             dir_parts->push_back(string(dir, part_start,
  432.                                         dir.length() - part_start));
  433.             break;
  434.         }
  436.         // If path starts from '/' - it's a root directory
  437.         if (sep_pos == 0) {
  438.             dir_parts->push_back(string(1, sep));
  439.         } else {
  440.             dir_parts->push_back(string(dir, part_start, sep_pos - part_start));
  441.         }
  443.         sep_pos++;
  444.         part_start = sep_pos;
  445.         if (sep_pos >= last_ind) 
  446.             break;
  447.     }
  449. }
  452. string CDirEntry::CreateRelativePath( const string& path_from, 
  453.                                       const string& path_to )
  454. {
  456. #if defined(NCBI_OS_MSWIN)  ||  defined(NCBI_OS_UNIX)
  457.     string path; // the result    
  458.     
  459.     if ( !IsAbsolutePath(path_from) ) {
  460.         NCBI_THROW(CFileException, eRelativePath, 
  461.                    "path_from is not absolute path");
  462.     }
  464.     if ( !IsAbsolutePath(path_to) ) {
  465.         NCBI_THROW(CFileException, eRelativePath, 
  466.                    "path_to is not absolute path");
  467.     }
  469.     // Split and strip FROM
  470.     string dir_from;
  471.     SplitPath(AddTrailingPathSeparator(path_from), &dir_from);
  472.     vector<string> dir_from_parts;
  473.     s_StripDir(dir_from, &dir_from_parts);
  474.     if ( dir_from_parts.empty() ) {
  475.         NCBI_THROW(CFileException, eRelativePath, 
  476.                    "path_from is empty path");
  477.     }
  479.     // Split and strip TO
  480.     string dir_to;
  481.     string base_to;
  482.     string ext_to;
  483.     SplitPath(path_to, &dir_to, &base_to, &ext_to);    
  484.     vector<string> dir_to_parts;
  485.     s_StripDir(dir_to, &dir_to_parts);
  486.     if ( dir_to_parts.empty() ) {
  487.         NCBI_THROW(CFileException, eRelativePath, 
  488.                    "path_to is empty path");
  489.     }
  491. //Platform-dependent compare mode
  492. #ifdef NCBI_OS_MSWIN
  493. # define DIR_PARTS_CMP_MODE NStr::eNocase
  494. #endif
  495. #ifdef NCBI_OS_UNIX
  496. # define DIR_PARTS_CMP_MODE NStr::eCase
  497. #endif
  498.     // Roots must be the same to create relative path from one to another
  500.     if (NStr::Compare(dir_from_parts.front(), 
  501.                       dir_to_parts.front(), 
  502.                       DIR_PARTS_CMP_MODE) != 0) {
  503.         NCBI_THROW(CFileException, eRelativePath, 
  504.                    "roots of input pathes are different");
  505.     }
  507.     size_t min_parts = min(dir_from_parts.size(), dir_to_parts.size());
  508.     size_t common_length = min_parts;
  509.     for (size_t i = 0; i < min_parts; i++) {
  510.         if (NStr::Compare(dir_from_parts[i], 
  511.                           dir_to_parts[i],
  512.                           DIR_PARTS_CMP_MODE) != 0) {
  513.             common_length = i;
  514.             break;
  515.         }
  516.     }
  518.     for (size_t i = common_length; i < dir_from_parts.size(); i++) {
  519.         path += "..";
  520.         path += GetPathSeparator();
  521.     }
  522.     for (size_t i = common_length; i < dir_to_parts.size(); i++) {
  523.         path += dir_to_parts[i];
  524.         path += GetPathSeparator();
  525.     }
  526.     
  527.     return path + base_to + ext_to;
  528. #else
  529.     NCBI_THROW(CFileException, eRelativePath, 
  530.                "not implemented");
  531.     return string();
  532. #endif
  533. }
  536. string CDirEntry::ConvertToOSPath(const string& path)
  537. {
  538.     // Not process empty and absolute path
  539.     if ( path.empty() || IsAbsolutePathEx(path) ) {
  540.         return path;
  541.     }
  542.     // Now we have relative "path"
  543.     string xpath = path;
  544.     // Add trailing separator if path ends with DIR_PARENT or DIR_CURRENT
  545. #if defined(DIR_PARENT)
  546.     if ( NStr::EndsWith(xpath, DIR_PARENT) )  {
  547.         xpath += DIR_SEPARATOR;
  548.     }
  549. #endif
  550. #if defined(DIR_CURRENT)
  551.     if ( NStr::EndsWith(xpath, DIR_CURRENT) )  {
  552.         xpath += DIR_SEPARATOR;
  553.     }
  554. #endif
  555.     // Replace each path separator with the current OS separator character
  556.     for (size_t i = 0; i < xpath.length(); i++) {
  557.         char c = xpath[i];
  558.         if ( c == '\' || c == '/' || c == ':') {
  559.             xpath[i] = DIR_SEPARATOR;
  560.         }
  561.     }
  562. #if defined(NCBI_OS_MAC)
  563.     // Fix current and parent refs in the path for MAC
  564.     string xsearch= "..:";
  565.     size_t pos = 0;
  566.     while ((pos = xpath.find(xsearch)) != NPOS) {
  567.         xpath.replace(pos, xsearch.length(), ":");
  568.         if ( xpath.substr(pos + 1, 2) == ".:" )  {
  569.             xpath.erase(pos + 1, 2);
  570.         } else {
  571.             if ( xpath.substr(pos + 1, xsearch.length()) != xsearch )  {
  572.                 xpath.insert(pos,":");
  573.             }
  574.         }
  575.     }
  576.     xpath = NStr::Replace(xpath, ".:", kEmptyStr);
  577.     // Add leading ":" (criterion of relativity of the dir)
  578.     if ( xpath[0] != ':' ) {
  579.         xpath = ":" + xpath;
  580.     }
  581. #else
  582.     // Fix current and parent refs in the path after conversion from MAC path
  583.     // Replace all "::" to "/../"
  584.     string xsearch  = string(2,DIR_SEPARATOR);
  585.     string xreplace = string(1,DIR_SEPARATOR) + DIR_PARENT + DIR_SEPARATOR;
  586.     size_t pos = 0;
  587.     while ((pos = xpath.find(xsearch, pos)) != NPOS ) {
  588.         xpath.replace(pos, xsearch.length(), xreplace);
  589.     }
  590.     // Remove leading ":" in the relative path on non-MAC platforms 
  591.     if ( xpath[0] == DIR_SEPARATOR ) {
  592.         xpath.erase(0,1);
  593.     }
  594.     // Replace something like "../aaa/../bbb/ccc" with "../bbb/ccc"
  595.     xpath = NormalizePath(xpath);
  596. #endif
  597.     return xpath;
  598. }
  601. string CDirEntry::ConcatPath(const string& first, const string& second)
  602. {
  603.     // Prepare first part of path
  604.     string path = AddTrailingPathSeparator(NStr::TruncateSpaces(first));
  605.     // Remove leading separator in "second" part
  606.     string part = NStr::TruncateSpaces(second);
  607.     if ( part.length() > 0  &&  part[0] == DIR_SEPARATOR ) {
  608.         part.erase(0,1);
  609.     }
  610.     // Add second part
  611.     path += part;
  612.     return path;
  613. }
  616. string CDirEntry::ConcatPathEx(const string& first, const string& second)
  617. {
  618.     // Prepare first part of path
  619.     string path = NStr::TruncateSpaces(first);
  621.     // Add trailing path separator to first part (OS independence)
  623.     size_t pos = path.length();
  624. #if defined(NCBI_OS_MAC)
  625.     if ( !pos ) {
  626.         path = string(1,GetPathSeparator());
  627.     }
  628. #endif
  629.     if ( pos  &&  string(ALL_OS_SEPARATORS).find(path.at(pos-1)) == NPOS ) {
  630.         // Find used path separator
  631.         char sep = GetPathSeparator();
  632.         size_t sep_pos = path.find_last_of(ALL_OS_SEPARATORS);
  633.         if ( sep_pos != NPOS ) {
  634.             sep = path.at(sep_pos);
  635.         }
  636.         path += sep;
  637.     }
  638.     // Remove leading separator in "second" part
  639.     string part = NStr::TruncateSpaces(second);
  640.     if ( part.length() > 0  &&
  641.          string(ALL_OS_SEPARATORS).find(part[0]) != NPOS ) {
  642.         part.erase(0,1);
  643.     }
  644.     // Add second part
  645.     path += part;
  646.     return path;
  647. }
  650. string CDirEntry::NormalizePath(const string& path, EFollowLinks follow_links)
  651. {
  652. #if defined(NCBI_OS_MSWIN)  ||  defined(NCBI_OS_UNIX)
  653.     static const char kSeps[] = { DIR_SEPARATOR,
  654. #  ifdef DIR_SEPARATOR_ALT
  655.                                   DIR_SEPARATOR_ALT,
  656. #  endif
  657.                                   '' };
  659.     list<string> head;              // already resolved to our satisfaction
  660.     string       current    = path; // to resolve next
  661.     list<string> tail;              // to resolve afterwards
  662.     int          link_depth = 0;
  664.     while ( !current.empty()  ||  !tail.empty() ) {
  665.         list<string> pretail;
  666.         if ( !current.empty() ) {
  667.             NStr::Split(current, kSeps, pretail, NStr::eNoMergeDelims);
  668.             current.erase();
  669.             if (pretail.front().empty()
  670. #  ifdef DISK_SEPARATOR
  671.                 ||  pretail.front().find(DISK_SEPARATOR) != NPOS
  672. #  endif
  673.                 ) {
  674.                 // absolute path
  675.                 head.clear();
  676. #  ifdef NCBI_OS_MSWIN
  677.                 // Remove leading "\?". Replace leading "\?UNC" with "\"
  678.                 static const char* const kUNC[] = { "", "", "?", "UNC" };
  679.                 list<string>::iterator it = pretail.begin();
  680.                 unsigned int matched = 0;
  681.                 while (matched < 4  &&  it != pretail.end()
  682.                        &&  !NStr::CompareNocase(*it, kUNC[matched])) {
  683.                     ++it;
  684.                     ++matched;
  685.                 }
  686.                 pretail.erase(pretail.begin(), it);
  687.                 switch (matched) {
  688.                 case 2: case 4: // got a UNC path (\... or \?UNC...)
  689.                     head.push_back(kEmptyStr);
  690.                     // fall through
  691.                 case 1: case 3/*?*/: // normal volume-less absolute path
  692.                     head.push_back(kEmptyStr);
  693.                     break;
  694.                 }
  695. #  endif
  696.             }
  697.             tail.splice(tail.begin(), pretail);
  698.         }
  700.         string next = tail.front();
  701.         tail.pop_front();
  702.         if ( !head.empty() ) { // empty heads should accept anything
  703.             string& last = head.back();
  704.             if (last == DIR_CURRENT) {
  705.                 head.pop_back();
  706.                 _ASSERT(head.empty());
  707.             } else if (next == DIR_CURRENT) {
  708.                 continue; // leave out, since we already have content
  709. #  ifdef DISK_SEPARATOR
  710.             } else if (last[last.size()-1] == DISK_SEPARATOR) {
  711.                 // allow almost anything right after a volume specification
  712. #  endif
  713.             } else if (next.empty()) {
  714.                 continue; // leave out empty components in most cases
  715.             } else if (next == DIR_PARENT) {
  716. #  ifdef DISK_SEPARATOR
  717.                 SIZE_TYPE pos;
  718. #  endif
  719.                 // back up if possible, assuming existing path to be "physical"
  720.                 if (last.empty()) {
  721.                     // already at the root; .. is a no-op
  722.                     continue;
  723. #  ifdef DISK_SEPARATOR
  724.                 } else if ((pos = last.find(DISK_SEPARATOR) != NPOS)) {
  725.                     last.erase(pos + 1);
  726. #  endif
  727.                 } else if (last != DIR_PARENT) {
  728.                     head.pop_back();
  729.                     continue;
  730.                 }
  731.             }
  732.         }
  733. #  ifdef NCBI_OS_UNIX
  734.         // Is there a Windows equivalent for readlink?
  735.         if (follow_links) {
  736.             string s(head.empty() ? next
  737.                      : NStr::Join(head, string(1, DIR_SEPARATOR))
  738.                      + DIR_SEPARATOR + next);
  739.             char buf[PATH_MAX];
  740.             int  length = readlink(s.c_str(), buf, sizeof(buf));
  741.             if (length > 0) {
  742.                 current.assign(buf, length);
  743.                 if (++link_depth >= 1024) {
  744.                     ERR_POST(Warning << "CDirEntry::NormalizePath: "
  745.                              "Reached symlink depth limit " << link_depth
  746.                              << " when resolving " << path);
  747.                     follow_links = eIgnoreLinks;
  748.                 }
  749.                 continue;
  750.             }
  751.         }
  752. #  endif
  753.         // normal case: just append the next element to head
  754.         head.push_back(next);
  755.     }
  756.     return NStr::Join(head, string(1, DIR_SEPARATOR));
  757. #else // Not Unix or  Windows
  758.     // NOT implemented!
  759.     return path;
  760. #endif
  761. }
  764. // Match "name" against the filename "mask", returning TRUE if
  765. // it matches, FALSE if not.  
  766. //
  767. bool CDirEntry::MatchesMask(const char* name, const char* mask) 
  768. {
  769.     return NStr::MatchesMask(name, mask);
  770. }
  773. bool CDirEntry::GetMode(TMode* user_mode, TMode* group_mode, TMode* other_mode)
  774.     const
  775. {
  776. #if defined(NCBI_OS_MAC)
  777.     FSSpec fss = FSS();
  778.     OSErr err = FSpCheckObjectLock(&fss);
  779.     if (err != noErr  &&  err != fLckdErr) {
  780.         return false;
  781.     }
  782.     bool locked = (err == fLckdErr);
  783.     TMode mode = fRead | (locked ? 0 : fWrite);
  784.     // User
  785.     if (user_mode) {
  786.         *user_mode = mode;
  787.     }
  788.     // Group
  789.     if (group_mode) {
  790.         *group_mode = mode;
  791.     }
  792.     // Other
  793.     if (other_mode) {
  794.         *other_mode = mode;
  795.     }
  796.     return true;
  797. #else
  798.     struct stat st;
  799.     if (stat(GetPath().c_str(), &st) != 0) {
  800.         return false;
  801.     }
  802.     // Other
  803.     if (other_mode) {
  804.         *other_mode = st.st_mode & 0007;
  805.     }
  806.     st.st_mode >>= 3;
  807.     // Group
  808.     if (group_mode) {
  809.         *group_mode = st.st_mode & 0007;
  810.     }
  811.     st.st_mode >>= 3;
  812.     // User
  813.     if (user_mode) {
  814.         *user_mode = st.st_mode & 0007;
  815.     }
  816.     return true;
  817. #endif
  818. }
  821. bool CDirEntry::SetMode(TMode user_mode, TMode group_mode, TMode other_mode)
  822.     const
  823. {
  824.     if (user_mode == fDefault) {
  825.         user_mode = m_DefaultMode[eUser];
  826.     }
  827. #if defined(NCBI_OS_MAC)
  828.     bool wantLocked = (user_mode & fWrite) == 0;
  829.     FSSpec fss = FSS();
  830.     OSErr  err = FSpCheckObjectLock(&fss);
  831.     if (err != noErr  &&  err != fLckdErr) {
  832.         return false;
  833.     }
  834.     bool locked = (err == fLckdErr);
  835.     if (locked == wantLocked) {
  836.         return true;
  837.     }
  838.     err = wantLocked 
  839.         ? ::FSpSetFLock(&fss) 
  840.         : ::FSpRstFLock(&fss);
  842.     return err == noErr;
  843. #else
  844.     if (group_mode == fDefault) {
  845.         group_mode = m_DefaultMode[eGroup];
  846.     }
  847.     if (other_mode == fDefault) {
  848.         other_mode = m_DefaultMode[eOther];
  849.     }
  850.     TMode mode = s_ConstructMode(user_mode, group_mode, other_mode);
  852.     return chmod(GetPath().c_str(), mode) == 0;
  853. #endif
  854. }
  857. void CDirEntry::SetDefaultModeGlobal(EType entry_type, TMode user_mode, 
  858.                                      TMode group_mode, TMode other_mode)
  859. {
  860.     if (entry_type >= eUnknown ) {
  861.         return;
  862.     }
  863.     if (entry_type == eDir ) {
  864.         if ( user_mode == fDefault ) {
  865.             user_mode = fDefaultDirUser;
  866.         }
  867.         if ( group_mode == fDefault ) {
  868.             group_mode = fDefaultDirGroup;
  869.         }
  870.         if ( other_mode == fDefault ) {
  871.             other_mode = fDefaultDirOther;
  872.         }
  873.     } else {
  874.         if ( user_mode == fDefault ) {
  875.             user_mode = fDefaultUser;
  876.         }
  877.         if ( group_mode == fDefault ) {
  878.             group_mode = fDefaultGroup;
  879.         }
  880.         if ( other_mode == fDefault ) {
  881.             other_mode = fDefaultOther;
  882.         }
  883.     }
  884.     m_DefaultModeGlobal[entry_type][eUser]  = user_mode;
  885.     m_DefaultModeGlobal[entry_type][eGroup] = group_mode;
  886.     m_DefaultModeGlobal[entry_type][eOther] = other_mode;
  887. }
  890. void CDirEntry::SetDefaultMode(EType entry_type, TMode user_mode, 
  891.                                TMode group_mode, TMode other_mode)
  892. {
  893.     if ( user_mode == fDefault ) {
  894.         user_mode = m_DefaultModeGlobal[entry_type][eUser];
  895.     }
  896.     if ( group_mode == fDefault ) {
  897.         group_mode = m_DefaultModeGlobal[entry_type][eGroup];
  898.     }
  899.     if ( other_mode == fDefault ) {
  900.         other_mode = m_DefaultModeGlobal[entry_type][eOther];
  901.     }
  902.     m_DefaultMode[eUser]  = user_mode;
  903.     m_DefaultMode[eGroup] = group_mode;
  904.     m_DefaultMode[eOther] = other_mode;
  905. }
  908. void CDirEntry::GetDefaultModeGlobal(EType  entry_type, TMode* user_mode,
  909.                                      TMode* group_mode, TMode* other_mode)
  910. {
  911.     if ( user_mode ) {
  912.         *user_mode = m_DefaultModeGlobal[entry_type][eUser];
  913.     }
  914.     if ( group_mode ) {
  915.         *group_mode = m_DefaultModeGlobal[entry_type][eGroup];
  916.     }
  917.     if ( other_mode ) {
  918.         *other_mode = m_DefaultModeGlobal[entry_type][eOther];
  919.     }
  920. }
  923. void CDirEntry::GetDefaultMode(TMode* user_mode, TMode* group_mode,
  924.                                TMode* other_mode) const
  925. {
  926.     if ( user_mode ) {
  927.         *user_mode = m_DefaultMode[eUser];
  928.     }
  929.     if ( group_mode ) {
  930.         *group_mode = m_DefaultMode[eGroup];
  931.     }
  932.     if ( other_mode ) {
  933.         *other_mode = m_DefaultMode[eOther];
  934.     }
  935. }
  938. bool CDirEntry::GetTime(CTime *modification,
  939.                         CTime *creation, CTime *last_access) const
  940. {
  941.     struct stat st;
  942.     if (stat(GetPath().c_str(), &st) != 0) {
  943.         return false;
  944.     }
  945.     if (modification) {
  946.         modification->SetTimeT(st.st_mtime);
  947.     }
  948.     if (creation) {
  949.         creation->SetTimeT(st.st_ctime);
  950.     }
  951.     if (last_access) {
  952.         last_access->SetTimeT(st.st_atime);
  953.     }
  955.     return true;
  956. }
  959. bool CDirEntry::SetTime(CTime *modification, CTime *last_access) const
  960. {
  961.     struct utimbuf times;
  963.     times.modtime = modification ? modification->GetTimeT() : time(0);
  964.     times.actime = last_access ? last_access->GetTimeT() : time(0);
  966.     return utime(GetPath().c_str(), &times) == 0;
  967. }
  969.  
  970. CDirEntry::EType CDirEntry::GetType(EFollowLinks follow) const
  971. {
  972. #if defined(NCBI_OS_MAC)
  973.     OSErr   err;
  974.     long    dirID;
  975.     Boolean isDir;
  976.     err = FSpGetDirectoryID(&FSS(), &dirID, &isDir);
  977.     if ( err ) {
  978.         return eUnknown;
  979.     }
  980.     return isDir ? eDir : eFile;
  982. #else
  983.     struct stat st;
  984.     int         errcode;
  985. #  if defined(NCBI_OS_MSWIN)
  986.     errcode = stat(GetPath().c_str(), &st);
  987. #  elif defined(NCBI_OS_UNIX)
  988.     if (follow == eFollowLinks) {
  989.         errcode = stat(GetPath().c_str(), &st);
  990.     } else {
  991.         errcode = lstat(GetPath().c_str(), &st);
  992.     }
  993. #  endif
  994.     if (errcode != 0) {
  995.         return eUnknown;
  996.     }
  997.     unsigned int mode = st.st_mode & S_IFMT;
  998.     switch (mode) {
  999.     case S_IFDIR:
  1000.         return eDir;
  1001.     case S_IFCHR:
  1002.         return eCharSpecial;
  1003. #  if defined(NCBI_OS_MSWIN)
  1004.     case _S_IFIFO:
  1005.         return ePipe;
  1006. #  elif defined(NCBI_OS_UNIX)
  1007.     case S_IFIFO:
  1008.         return ePipe;
  1009.     case S_IFLNK:
  1010.         return eLink;
  1011.     case S_IFSOCK:
  1012.         return eSocket;
  1013.     case S_IFBLK:
  1014.         return eBlockSpecial;
  1015. #    if defined(S_IFDOOR) /* only Solaris seems to have this */
  1016.     case S_IFDOOR:
  1017.         return eDoor;
  1018. #    endif
  1019. #  endif
  1020.     }
  1021.     // Check regular file bit last
  1022.     if ( (st.st_mode & S_IFREG)  == S_IFREG ) {
  1023.         return eFile;
  1024.     }
  1025.     return eUnknown;
  1026. #endif
  1027. }
  1030. bool CDirEntry::Rename(const string& newname)
  1031. {
  1032. #if defined(NCBI_OS_MAC)
  1033.     const int maxFilenameLength = 31;
  1034.     if (newname.length() > maxFilenameLength) return false;
  1035.     Str31 newNameStr;
  1036.     Pstrcpy(newNameStr, newname.c_str());
  1037.     OSErr err = FSpRename(&FSS(), newNameStr);
  1038.     if (err != noErr) return false;
  1039. #else
  1040.     if (rename(GetPath().c_str(), newname.c_str()) != 0) {
  1041.         return false;
  1042.     }
  1043. #endif
  1044.     Reset(newname);
  1045.     return true;
  1046. }
  1049. bool CDirEntry::Remove(EDirRemoveMode mode) const
  1050. {
  1051. #if defined(NCBI_OS_MAC)
  1052.     OSErr err = ::FSpDelete(&FSS());
  1053.     return err == noErr;
  1054. #else
  1055.     if ( IsDir(eIgnoreLinks) ) {
  1056.         if (mode == eOnlyEmpty) {
  1057.             return rmdir(GetPath().c_str()) == 0;
  1058.         } else {
  1059.             CDir dir(GetPath());
  1060.             return dir.Remove(eRecursive);
  1061.         }
  1062.     } else {
  1063.         return remove(GetPath().c_str()) == 0;
  1064.     }
  1065. #endif
  1066. }
  1070. //////////////////////////////////////////////////////////////////////////////
  1071. //
  1072. // CFile
  1073. //
  1075. CFile::CFile(const string& filename) : CParent(filename)
  1076. { 
  1077.     // Set default mode
  1078.     SetDefaultMode(eFile, fDefault, fDefault, fDefault);
  1079. }
  1082. CFile::~CFile(void)
  1083. { 
  1084.     return;
  1085. }
  1088. Int8 CFile::GetLength(void) const
  1089. {
  1090. #if defined(NCBI_OS_MAC)
  1091.     long dataSize, rsrcSize;
  1092.     OSErr err = FSpGetFileSize(&FSS(), &dataSize, &rsrcSize);
  1093.     if (err != noErr) {
  1094.         return -1;
  1095.     } else {
  1096.         return dataSize;
  1097.     }
  1098. #else
  1099.     struct stat buf;
  1100.     if ( stat(GetPath().c_str(), &buf) != 0 ) {
  1101.         return -1;
  1102.     }
  1103.     return buf.st_size;
  1104. #endif
  1105. }
  1108. string CFile::GetTmpName(ETmpFileCreationMode mode)
  1109. {
  1110. #if defined(NCBI_OS_MSWIN)  ||  defined(NCBI_OS_UNIX)
  1111.     return GetTmpNameEx(kEmptyStr, kEmptyStr, mode);
  1112. #else
  1113.     if (mode == eTmpFileCreate) {
  1114.         ERR_POST(Warning << "CFile::GetTmpNameEx: "
  1115.                  "The temporary file cannot be auto-created on this " 
  1116.                  "platform, returns its name only");
  1117.     }
  1118.     char* filename = tempnam(0,0);
  1119.     if ( !filename ) {
  1120.         return kEmptyStr;
  1121.     }
  1122.     string res(filename);
  1123.     free(filename);
  1124.     return res;
  1125. #endif
  1126. }
  1129. #if !defined(NCBI_OS_UNIX)
  1131. static string s_StdGetTmpName(const char* dir, const char* prefix)
  1132. {
  1133.     char* filename = tempnam(dir, prefix);
  1134.     if ( !filename ) {
  1135.         return kEmptyStr;
  1136.     }
  1137.     string str(filename);
  1138.     free(filename);
  1139.     return str;
  1140. }
  1142. #endif
  1145. string CFile::GetTmpNameEx(const string&        dir, 
  1146.                            const string&        prefix,
  1147.                            ETmpFileCreationMode mode)
  1148. {
  1149. #if defined(NCBI_OS_MSWIN)  ||  defined(NCBI_OS_UNIX)
  1150.     string x_dir = dir;
  1151.     if ( x_dir.empty() ) {
  1152.         x_dir = CDir::GetTmpDir();
  1153.     }
  1154.     if ( !x_dir.empty() ) {
  1155.         x_dir = AddTrailingPathSeparator(x_dir);
  1156.     }
  1158.     string fn;
  1160. #  if defined(NCBI_OS_UNIX)
  1161.     string pattern = x_dir + prefix + "XXXXXX";
  1162.     AutoPtr<char, CDeleter<char> > filename(strdup(pattern.c_str()));
  1163.     int fd = mkstemp(filename.get());
  1164.     close(fd);
  1165.     if (mode != eTmpFileCreate) {
  1166.         remove(filename.get());
  1167.     }
  1168.     fn = filename.get();
  1170. #  elif defined(NCBI_OS_MSWIN)
  1171.     if (mode == eTmpFileGetName) {
  1172.         fn = s_StdGetTmpName(dir.c_str(), prefix.c_str());
  1173.     } else {
  1174.         char   buffer[MAX_PATH];
  1175.         HANDLE hFile = INVALID_HANDLE_VALUE;
  1177.         srand((unsigned)time(0));
  1178.         unsigned long ofs = rand();
  1180.         while ( ofs < numeric_limits<unsigned long>::max() ) {
  1181.             _ultoa((unsigned long)ofs, buffer, 24);
  1182.             fn = x_dir + prefix + buffer;
  1183.             hFile = CreateFile(fn.c_str(), GENERIC_ALL, 0, NULL,
  1184.                                CREATE_NEW, FILE_ATTRIBUTE_TEMPORARY, NULL);
  1185.             if (hFile != INVALID_HANDLE_VALUE) {
  1186.                 break;
  1187.             }
  1188.             ofs++;
  1189.         }
  1190.         CloseHandle(hFile);
  1191.         if (ofs == numeric_limits<unsigned long>::max() ) {
  1192.             return kEmptyStr;
  1193.         }
  1194.         if (mode != eTmpFileCreate) {
  1195.             remove(fn.c_str());
  1196.         }
  1197.     }
  1199. #  endif
  1201. #else // defined(NCBI_OS_MSWIN)  ||  defined(NCBI_OS_UNIX)
  1202.     if (mode == eTmpFileCreate) {
  1203.         ERR_POST(Warning << "CFile::GetTmpNameEx: "
  1204.                  "The file cannot be auto-created on this platform, " 
  1205.                  "return its name only");
  1206.     }
  1207.     fn = s_StdGetTmpName(dir.c_str(), prefix.c_str());
  1208. #endif
  1209.     return fn;
  1210. }
  1213. class CTmpStream : public fstream
  1214. {
  1215. public:
  1216.     CTmpStream(const char *s, IOS_BASE::openmode mode) : fstream(s, mode) 
  1217.     {
  1218.         m_FileName = s; 
  1219.     }
  1220.     virtual ~CTmpStream(void) 
  1221.     { 
  1222.         close();
  1223.         CFile(m_FileName).Remove();
  1224.     }
  1225. protected:
  1226.     string m_FileName;
  1227. };
  1230. fstream* CFile::CreateTmpFile(const string& filename, 
  1231.                               ETextBinary text_binary,
  1232.                               EAllowRead  allow_read)
  1233. {
  1234.     ios::openmode mode = ios::out | ios::trunc;
  1235.     if ( text_binary == eBinary ) {
  1236.         mode = mode | ios::binary;
  1237.     }
  1238.     if ( allow_read == eAllowRead ) {
  1239.         mode = mode | ios::in;
  1240.     }
  1241.     string tmpname = filename.empty() ? GetTmpName(eTmpFileCreate) : filename;
  1242.     if ( tmpname.empty() ) {
  1243.         return 0;
  1244.     }
  1245.     fstream* stream = new CTmpStream(tmpname.c_str(), mode);
  1246.     return stream;
  1247. }
  1250. fstream* CFile::CreateTmpFileEx(const string& dir, const string& prefix,
  1251.                                 ETextBinary text_binary, 
  1252.                                 EAllowRead allow_read)
  1253. {
  1254.     return CreateTmpFile(GetTmpNameEx(dir, prefix, eTmpFileCreate),
  1255.                          text_binary, allow_read);
  1256. }
  1260. //////////////////////////////////////////////////////////////////////////////
  1261. //
  1262. // CDir
  1263. //
  1266. CDir::CDir(void)
  1267. {
  1268.     return;
  1269. }
  1272. #if defined(NCBI_OS_MAC)
  1273. CDir::CDir(const FSSpec& fss) : CParent(fss)
  1274. {
  1275.     // Set default mode
  1276.     SetDefaultMode(eDir, fDefault, fDefault, fDefault);
  1277. }
  1278. #endif
  1281. CDir::CDir(const string& dirname) : CParent(dirname)
  1282. {
  1283.     // Set default mode
  1284.     SetDefaultMode(eDir, fDefault, fDefault, fDefault);
  1285. }
  1288. #if defined(NCBI_OS_UNIX)
  1290. static bool s_GetHomeByUID(string& home)
  1291. {
  1292.     // Get the info using user ID
  1293.     struct passwd *pwd;
  1295.     if ((pwd = getpwuid(getuid())) == 0) {
  1296.         return false;
  1297.     }
  1298.     home = pwd->pw_dir;
  1299.     return true;
  1300. }
  1302. static bool s_GetHomeByLOGIN(string& home)
  1303. {
  1304.     char* ptr = 0;
  1305.     // Get user name
  1306.     if ( !(ptr = getenv("USER")) ) {
  1307.         if ( !(ptr = getenv("LOGNAME")) ) {
  1308.             if ( !(ptr = getlogin()) ) {
  1309.                 return false;
  1310.             }
  1311.         }
  1312.     }
  1313.     // Get home dir for this user
  1314.     struct passwd* pwd = getpwnam(ptr);
  1315.     if ( !pwd ||  pwd->pw_dir[0] == '') {
  1316.         return false;
  1317.     }
  1318.     home = pwd->pw_dir;
  1319.     return true;
  1320. }
  1321. #endif // NCBI_OS_UNIX
  1324. string CDir::GetHome(void)
  1325. {
  1326.     char*  str;
  1327.     string home;
  1329. #if defined(NCBI_OS_MSWIN)
  1330.     // Get home dir from environment variables
  1331.     // like - C:Documents and SettingsuserApplication Data
  1332.     str = getenv("APPDATA");
  1333.     if ( str ) {
  1334.         home = str;
  1335.     } else {
  1336.         // like - C:Documents and Settingsuser
  1337.         str = getenv("USERPROFILE");
  1338.         if ( str ) {
  1339.             home = str;
  1340.         }
  1341.     }
  1342.    
  1343. #elif defined(NCBI_OS_UNIX)
  1344.     // Try get home dir from environment variable
  1345.     str = getenv("HOME");
  1346.     if ( str ) {
  1347.         home = str;
  1348.     } else {
  1349.         // Try to retrieve the home dir -- first use user's ID, and if failed, 
  1350.         // then use user's login name.
  1351.         if ( !s_GetHomeByUID(home) ) { 
  1352.             s_GetHomeByLOGIN(home);
  1353.         }
  1354.     }
  1355.    
  1356. #elif defined(NCBI_OS_MAC)
  1357.     // Make sure we can use FindFolder() if not, report error
  1358.     long gesResponse;
  1359.     if (Gestalt(gestaltFindFolderAttr, &gesResponse) != noErr  ||
  1360.         (gesResponse & (1 << gestaltFindFolderPresent) == 0)) {
  1361.         return kEmptyStr;
  1362.     }
  1364.     // Store the current active directory
  1365.     long  saveDirID;
  1366.     short saveVRefNum;
  1367.     HGetVol((StringPtr) 0, &saveVRefNum, &saveDirID);
  1369.     // Find the preferences folder in the active System folder
  1370.     short vRefNum;
  1371.     long  dirID;
  1372.     OSErr err = FindFolder(kOnSystemDisk, kPreferencesFolderType,
  1373.                            kCreateFolder, &vRefNum, &dirID);
  1375.     FSSpec spec;
  1376.     if (err == noErr) {
  1377.         char dummy[FILENAME_MAX+1];
  1378.         dummy [0] = '';
  1379.         err = FSMakeFSSpec(vRefNum, dirID, (StringPtr) dummy, &spec);
  1380.     }
  1382.     // Restore the current active directory
  1383.     HSetVol((StringPtr) 0, saveVRefNum, saveDirID);
  1385.     // Convert to C++ string
  1386.     if (err == noErr) {
  1387.         str = 0;
  1388.         err = MacFSSpec2FullPathname(&spec, &str);
  1389.         home = str;
  1390.     }
  1391. #endif 
  1393.     // Add trailing separator if needed
  1394.     return AddTrailingPathSeparator(home);
  1395. }
  1399. string CDir::GetTmpDir(void)
  1400. {
  1401.     string tmp;
  1403. #if defined(NCBI_OS_UNIX)
  1405.     char* tmpdir = getenv("TMPDIR");
  1406.     if ( tmpdir ) {
  1407.         tmp = tmpdir;
  1408.     } else  {
  1409. #  if defined(P_tmpdir)
  1410.         tmp = P_tmpdir;
  1411. #  else
  1412.         tmp = "/tmp";
  1413. #  endif
  1414.     }
  1416. #elif defined(NCBI_OS_MSWIN)
  1418.     char* tmpdir = getenv("TEMP");
  1419.     if ( tmpdir ) {
  1420.         tmp = tmpdir;
  1421.     } else  {
  1422. #  if defined(P_tmpdir)
  1423.         tmp = P_tmpdir;
  1424. #  else
  1425.         tmp = CDir::GetHome();
  1426. #  endif
  1427.     }
  1429. #endif
  1431.     return tmp;
  1432. }
  1435. string CDir::GetCwd()
  1436. {
  1437.     string cwd;
  1439. #if defined(NCBI_OS_UNIX)
  1441.     char buf[4096];
  1442.     if (getcwd(buf, sizeof(buf) - 1)) {
  1443.         cwd = buf;
  1444.     }
  1446. #elif defined(NCBI_OS_MSWIN)
  1448.     char buf[4096];
  1449.     if (_getcwd(buf, sizeof(buf) - 1)) {
  1450.         cwd = buf;
  1451.     }
  1453. #endif
  1455.     return cwd;
  1456. }
  1459. CDir::~CDir(void)
  1460. {
  1461.     return;
  1462. }
  1465. #if defined(NCBI_OS_MAC)
  1466. static const CDirEntry MacGetIndexedItem(const CDir& container, SInt16 index)
  1467. {
  1468.     FSSpec dir = container.FSS();
  1469.     FSSpec fss;     // FSSpec of item gotten.
  1470.     SInt16 actual;  // Actual number of items gotten.  Should be one or zero.
  1471.     SInt16 itemIndex = index;
  1472.     OSErr err = GetDirItems(dir.vRefNum, dir.parID, dir.name, true, true, 
  1473.                             &fss, 1, &actual, &itemIndex);
  1474.     if (err != noErr) {
  1475.         throw err;
  1476.     }
  1477.     return CDirEntry(fss);
  1478. }
  1479. #endif
  1482. CDir::TEntries CDir::GetEntries(const string&   mask,
  1483.                                 EGetEntriesMode mode) const
  1484. {
  1485.     TEntries contents;
  1486.     string x_mask    = mask.empty() ? string("*") : mask;
  1487.     string path_base = GetPath();
  1488.     if ( path_base[path_base.size() - 1] != GetPathSeparator() ) {
  1489.         path_base += GetPathSeparator();
  1490.     }
  1492. #if defined(NCBI_OS_MSWIN)
  1493.     // Append to the "path" mask for all files in directory
  1494.     string pattern = path_base + x_mask;
  1496.     // Open directory stream and try read info about first entry
  1497.     struct _finddata_t entry;
  1498.     long desc = _findfirst(pattern.c_str(), &entry);  // get first entry's name
  1499.     if (desc != -1) {
  1500.         CDirEntry* dir_entry = new CDirEntry(path_base + entry.name);
  1501.         if (mode == eIgnoreRecursive) {
  1502.             if ((::strcmp(entry.name, ".") == 0) ||
  1503.                 (::strcmp(entry.name, "..") == 0)) 
  1504.             {
  1505.                 delete dir_entry;
  1506.                 dir_entry = 0;
  1507.             }
  1508.         }
  1509.         if (dir_entry)
  1510.             contents.push_back(dir_entry);
  1512.         while ( _findnext(desc, &entry) != -1 ) {
  1513.             if (mode == eIgnoreRecursive) {
  1514.                 if ((::strcmp(entry.name, ".") == 0) ||
  1515.                     (::strcmp(entry.name, "..") == 0)) continue;
  1516.             }
  1518.             contents.push_back(new CDirEntry(path_base + entry.name));
  1519.         }
  1520.         _findclose(desc);
  1521.     }
  1523. #elif defined(NCBI_OS_UNIX)
  1524.     DIR* dir = opendir(GetPath().c_str());
  1525.     if ( dir ) {
  1526.         while (struct dirent* entry = readdir(dir)) {
  1527.             if ( MatchesMask(entry->d_name, x_mask.c_str()) ) {
  1528.                 if (mode == eIgnoreRecursive) {
  1529.                     if ((::strcmp(entry->d_name, ".") == 0) ||
  1530.                         (::strcmp(entry->d_name, "..") == 0)) continue;
  1531.                 }
  1532.                 contents.push_back(new CDirEntry(path_base + entry->d_name));
  1533.             }
  1534.         }
  1535.         closedir(dir);
  1536.     }
  1538. #elif defined(NCBI_OS_MAC)
  1539.     try {
  1540.         for (int index = 1;  ;  index++) {
  1541.             CDirEntry entry = MacGetIndexedItem(*this, index);
  1542.             if ( MatchesMask(entry.GetName().c_str(), x_mask.c_str()) ) {
  1543.                 contents.push_back(new CDirEntry(entry));
  1544.             }
  1545.         }
  1546.     } catch (OSErr& err) {
  1547.         if (err != fnfErr) {
  1548.             throw COSErrException_Mac(err, "CDir::GetEntries() ");
  1549.         }
  1550.     }
  1551. #endif
  1553.     return contents;
  1554. }
  1557. CDir::TEntries CDir::GetEntries(const vector<string>&  masks,
  1558.                                 EGetEntriesMode        mode) const
  1559. {
  1560.     if (masks.empty())
  1561.         return GetEntries();
  1563.     TEntries contents;
  1564.     string path_base = GetPath();
  1565.     if ( path_base[path_base.size() - 1] != GetPathSeparator() ) {
  1566.         path_base += GetPathSeparator();
  1567.     }
  1569. #if defined(NCBI_OS_MSWIN)
  1571.     // Append to the "path" mask for all files in directory
  1572.     string pattern = path_base + string("*");
  1574.     bool skip_recursive_entry;
  1576.     // Open directory stream and try read info about first entry
  1577.     struct _finddata_t entry;
  1578.     long desc = _findfirst(pattern.c_str(), &entry);  // get first entry's name
  1579.     if (desc != -1) {
  1580.         skip_recursive_entry =
  1581.             (mode == eIgnoreRecursive) &&
  1582.             ((::strcmp(entry.name, ".") == 0) ||
  1583.              (::strcmp(entry.name, "..") == 0));
  1585.         // check all masks
  1586.         if (!skip_recursive_entry) {
  1587.             ITERATE(vector<string>, it, masks) {
  1588.                 const string& mask = *it;
  1589.                 if (mask.empty()) {
  1590.                     contents.push_back(new CDirEntry(path_base + entry.name));
  1591.                     break;
  1592.                 }
  1593.                 if (MatchesMask(entry.name, mask.c_str()) ) {
  1594.                     contents.push_back(new CDirEntry(path_base + entry.name));
  1595.                     break;
  1596.                 }                
  1597.             } // ITERATE
  1598.         }
  1600.         while ( _findnext(desc, &entry) != -1 ) {
  1601.             skip_recursive_entry =
  1602.                 (mode == eIgnoreRecursive) &&
  1603.                 ((::strcmp(entry.name, ".") == 0) ||
  1604.                  (::strcmp(entry.name, "..") == 0));
  1606.             if (skip_recursive_entry) {
  1607.                 continue;
  1608.             }
  1609.             ITERATE(vector<string>, it, masks) {
  1610.                 const string& mask = *it;
  1611.                 if (mask.empty()) {
  1612.                     contents.push_back(new CDirEntry(path_base + entry.name));
  1613.                     break;
  1614.                 }
  1615.                 if (MatchesMask(entry.name, mask.c_str()) ) {
  1616.                     contents.push_back(new CDirEntry(path_base + entry.name));
  1617.                     break;
  1618.                 }
  1619.             } // ITERATE
  1620.         }
  1621.         _findclose(desc);
  1622.     }
  1625. #elif defined(NCBI_OS_UNIX)
  1626.     DIR* dir = opendir(GetPath().c_str());
  1627.     if ( dir ) {
  1628.         while (struct dirent* entry = readdir(dir)) {
  1630.             bool skip_recursive_entry =
  1631.                     (mode == eIgnoreRecursive) &&
  1632.                     ((::strcmp(entry->d_name, ".") == 0) ||
  1633.                      (::strcmp(entry->d_name, "..") == 0));
  1634.             if (skip_recursive_entry) {
  1635.                 continue;
  1636.             }
  1637.             ITERATE(vector<string>, it, masks) {
  1638.                 const string& mask = *it;
  1639.                 if (mask.empty()) {
  1640.                     contents.push_back(
  1641.                          new CDirEntry(path_base + entry->d_name));
  1642.                     break;
  1643.                 }
  1644.                 if ( MatchesMask(entry->d_name, mask.c_str()) ) {
  1645.                     contents.push_back(
  1646.                          new CDirEntry(path_base + entry->d_name));
  1647.                     break;
  1648.                 }
  1649.             } // ITERATE
  1650.         } // while
  1651.         closedir(dir);
  1652.     }
  1654. #elif defined(NCBI_OS_MAC)
  1655.     try {
  1656.         for (int index = 1;  ;  index++) {
  1657.             CDirEntry entry = MacGetIndexedItem(*this, index);
  1658.             ITERATE(vector<string>, it, masks) {
  1659.                 const string& mask = *it;
  1660.                 if (mask.empty()) {
  1661.                     contents.push_back(new CDirEntry(entry));
  1662.                     break;
  1663.                 }
  1664.                 if ( MatchesMask(entry.GetName().c_str(), mask.c_str()) ) {
  1665.                     contents.push_back(new CDirEntry(entry));
  1666.                     break;
  1667.                 }
  1668.             }
  1669.         }
  1670.     } catch (OSErr& err) {
  1671.         if (err != fnfErr) {
  1672.             throw COSErrException_Mac(err, "CDir::GetEntries() ");
  1673.         }
  1674.     }
  1675. #endif
  1677.     return contents;
  1678. }
  1681. bool CDir::Create(void) const
  1682. {
  1683.     TMode user_mode, group_mode, other_mode;
  1685.     GetDefaultMode(&user_mode, &group_mode, &other_mode);
  1686.     TMode mode = s_ConstructMode(user_mode, group_mode, other_mode);
  1688. #if defined(NCBI_OS_MSWIN)
  1689.     if ( mkdir(GetPath().c_str()) != 0 ) {
  1690.         return false;
  1691.     }
  1692.     return chmod(GetPath().c_str(), mode) == 0;
  1694. #elif defined(NCBI_OS_UNIX)
  1696.     return mkdir(GetPath().c_str(), mode) == 0;
  1698. #elif defined(NCBI_OS_MAC)
  1699.     OSErr err;
  1700.     long dirID;
  1702.     err = ::FSpDirCreate(&FSS(), smRoman, &dirID);
  1703.     return err == noErr;
  1705. #endif
  1706. }
  1708. bool CDir::CreatePath(void) const
  1709. {
  1710.     if (Exists()) {
  1711.         return true;
  1712.     }
  1713.     string path(GetPath());
  1714.     if (path.empty()) {
  1715.         return true;
  1716.     }
  1717.     if (path[path.length()-1] == GetPathSeparator()) {
  1718.         path.erase(path.length() - 1);
  1719.     }
  1720.     CDir dir_this(path);
  1721.     if (dir_this.Exists()) {
  1722.         return true;
  1723.     }
  1724.     string path_up = dir_this.GetDir();
  1725.     if (path_up == path) {
  1726.         // special case: is this a disk name?
  1727.         return true;
  1728.     } 
  1729.     CDir dir_up(path_up);
  1730.     if (dir_up.CreatePath()) {
  1731.         return dir_this.Create();
  1732.     }
  1733.     return false;
  1734. }
  1736. bool CDir::Remove(EDirRemoveMode mode) const
  1737. {
  1738.     // Remove directory as empty
  1739.     if ( mode == eOnlyEmpty ) {
  1740.         return CParent::Remove(eOnlyEmpty);
  1741.     }
  1742.     // Read all entryes in derectory
  1743.     TEntries contents = GetEntries();
  1745.     // Remove
  1746.     ITERATE(TEntries, entry, contents) {
  1747.         string name = (*entry)->GetName();
  1748. #if defined(NCBI_OS_MAC)
  1749.         CDirEntry& item = **entry;
  1750. #else
  1751.         if ( name == "."  ||  name == ".."  ||  
  1752.              name == string(1,GetPathSeparator()) ) {
  1753.             continue;
  1754.         }
  1755.         // Get entry item with full pathname
  1756.         CDirEntry item(GetPath() + GetPathSeparator() + name);
  1757. #endif
  1758.         if ( mode == eRecursive ) {
  1759.             if ( !item.Remove(eRecursive) ) {
  1760.                 return false;
  1761.             }
  1762.         } else {
  1763.             if ( item.IsDir(eIgnoreLinks) ) {
  1764.                 continue;
  1765.             }
  1766.             if ( !item.Remove() ) {
  1767.                 return false;
  1768.             }
  1769.         }
  1770.     }
  1771.     // Remove main directory
  1772.     return CParent::Remove(eOnlyEmpty);
  1773. }
  1776. //////////////////////////////////////////////////////////////////////////////
  1777. //
  1778. // CMemoryFile
  1779. //
  1782. // Platform-dependent memory file handle definition
  1783. struct SMemoryFileHandle {
  1784. #if defined(NCBI_OS_MSWIN)
  1785.     HANDLE  hMap;
  1786. #else
  1787.     int     hDummy;
  1788. #endif
  1789. };
  1792. bool CMemoryFile::IsSupported(void)
  1793. {
  1794. #if defined(NCBI_OS_MAC)
  1795.     return false;
  1796. #else
  1797.     return true;
  1798. #endif
  1799. }
  1802. CMemoryFile::CMemoryFile(const string&  file_name,
  1803.                          EMemMapProtect protect,
  1804.                          EMemMapShare   share)
  1805.     : m_Handle(0), m_Size(-1), m_DataPtr(0)
  1806. {
  1807.     x_Map(file_name, protect, share);
  1809.     if (GetSize() < 0) {
  1810.         NCBI_THROW(CFileException, eMemoryMap,
  1811.                    "File memory mapping cannot be created");
  1812.     }
  1813. }
  1816. CMemoryFile::~CMemoryFile(void)
  1817. {
  1818.     Unmap();
  1819. }
  1822. void CMemoryFile::x_Map(const string&  file_name,
  1823.                         EMemMapProtect protect_attr,
  1824.                         EMemMapShare   share_attr)
  1825. {
  1826.     if ( !IsSupported() )
  1827.         return;
  1829.     m_Handle = new SMemoryFileHandle();
  1831.     for (;;) { // quasi-TRY block
  1833.         CFile file(file_name);
  1834.         m_Size = file.GetLength();
  1836.         if (m_Size < 0)
  1837.             break;
  1839.         // Special case
  1840.         if (m_Size == 0)
  1841.             return;
  1843. #if defined(NCBI_OS_MSWIN)
  1844.         // Name of a file-mapping object cannot contain ''
  1845.         string x_name = NStr::Replace(file_name, "\", "/");
  1847.         // Translate attributes 
  1848.         DWORD map_protect = 0, map_access = 0, file_share = 0, file_access = 0;
  1849.         switch (protect_attr) {
  1850.             case eMMP_Read:
  1851.                 map_access  = FILE_MAP_READ;
  1852.                 map_protect = PAGE_READONLY;
  1853.                 file_access = GENERIC_READ;
  1854.                 break;
  1855.             case eMMP_Write:
  1856.             case eMMP_ReadWrite:
  1857.                 // On MS Windows platform Write & ReadWrite access
  1858.                 // to the mapped memory is equivalent
  1859.                 if  (share_attr == eMMS_Shared ) {
  1860.                     map_access = FILE_MAP_ALL_ACCESS;
  1861.                 } else {
  1862.                     map_access = FILE_MAP_COPY;
  1863.                 }
  1864.                 map_protect = PAGE_READWRITE;
  1865.                 // So the file also must be open for reading and writing
  1866.                 file_access = GENERIC_READ | GENERIC_WRITE;
  1867.                 break;
  1868.             default:
  1869.                 _TROUBLE;
  1870.         }
  1871.         if (share_attr == eMMS_Shared) {
  1872.             file_share = FILE_SHARE_READ | FILE_SHARE_WRITE;
  1873.         } else {
  1874.             file_share = 0;
  1875.         }
  1877.         // If failed to attach to an existing file-mapping object then
  1878.         // create a new one (based on the specified file)
  1879.         m_Handle->hMap = OpenFileMapping(map_access, false, x_name.c_str());
  1880.         if ( !m_Handle->hMap ) { 
  1881.             HANDLE hFile = CreateFile(x_name.c_str(), file_access, 
  1882.                                       file_share, NULL, OPEN_EXISTING, 
  1883.                                       FILE_ATTRIBUTE_NORMAL, NULL);
  1884.             if (hFile == INVALID_HANDLE_VALUE)
  1885.                 break;
  1887.             m_Handle->hMap = CreateFileMapping(hFile, NULL, map_protect,
  1888.                                                0, 0, x_name.c_str());
  1889.             CloseHandle(hFile);
  1890.             if ( !m_Handle->hMap )
  1891.                 break;
  1892.         }
  1893.         m_DataPtr = MapViewOfFile(m_Handle->hMap, map_access,
  1894.                                   0, 0, m_Size);
  1895.         if ( !m_DataPtr ) {
  1896.             CloseHandle(m_Handle->hMap);
  1897.             break;
  1898.         }
  1900. #elif defined(NCBI_OS_UNIX)
  1901.         // Translate attributes 
  1902.         int map_protect = 0, map_share = 0, file_access = 0;
  1903.         switch (protect_attr) {
  1904.             case eMMP_Read:
  1905.                 map_protect = PROT_READ;
  1906.                 file_access = O_RDONLY;
  1907.                 break;
  1908.             case eMMP_Write:
  1909.                 map_protect = PROT_WRITE;
  1910.                 if  (share_attr == eMMS_Shared ) {
  1911.                     // Must be read + write
  1912.                     file_access = O_RDWR;
  1913.                 } else {
  1914.                     file_access = O_RDONLY;
  1915.                 }
  1916.                 break;
  1917.             case eMMP_ReadWrite:
  1918.                 map_protect = PROT_READ | PROT_WRITE;
  1919.                 if  (share_attr == eMMS_Shared ) {
  1920.                     file_access = O_RDWR;
  1921.                 } else {
  1922.                     file_access = O_RDONLY;
  1923.                 }
  1924.                 break;
  1925.             default:
  1926.                 _TROUBLE;
  1927.         }
  1928.         switch (share_attr) {
  1929.             case eMMS_Shared:
  1930.                 map_share = MAP_SHARED;
  1931.                 break;
  1932.             case eMMS_Private:
  1933.                 map_share = MAP_PRIVATE;
  1934.                 break;
  1935.             default:
  1936.                 _TROUBLE;
  1937.         }
  1938.         // Open file
  1939.         int fd = open(file_name.c_str(), file_access);
  1940.         if (fd < 0) {
  1941.             break;
  1942.         }
  1943.         // Map file to memory
  1944.         m_DataPtr = mmap(0, (size_t) m_Size, map_protect, map_share, fd, 0);
  1945.         close(fd);
  1946.         if (m_DataPtr == MAP_FAILED) {
  1947.             break;
  1948.         }
  1949. #endif
  1951.         // Success
  1952.         return;
  1953.     }
  1955.     // Error; cleanup
  1956.     delete m_Handle;
  1957.     m_Handle = 0;
  1958.     m_Size = -1;
  1959. }
  1962. bool CMemoryFile::Flush(void) const
  1963. {
  1964.     // If file is not mapped do nothing
  1965.     if ( !m_Handle )
  1966.         return false;
  1967.     bool status = false;
  1969. #if defined(NCBI_OS_MSWIN)
  1970.     status = (FlushViewOfFile(m_DataPtr, 0) != 0);
  1971. #elif defined(NCBI_OS_UNIX)
  1972.     status = (msync((char*)m_DataPtr, (size_t) m_Size, MS_SYNC) == 0);
  1973. #endif
  1974.     return status;
  1975. }
  1978. bool CMemoryFile::Unmap(void)
  1979. {
  1980.     // If file is not mapped do nothing
  1981.     if ( !m_Handle )
  1982.         return true;
  1983.     bool status = false;
  1985. #if defined(NCBI_OS_MSWIN)
  1986.     status = (UnmapViewOfFile(m_DataPtr) != 0);
  1987.     if ( status  &&  m_Handle->hMap )
  1988.         status = (CloseHandle(m_Handle->hMap) != 0);
  1989. #elif defined(NCBI_OS_UNIX)
  1990.     status = (munmap((char*)m_DataPtr, (size_t) m_Size) == 0);
  1991. #endif
  1992.     delete m_Handle;
  1994.     // Reinitialize members
  1995.     m_Handle = 0;
  1996.     m_DataPtr = 0;
  1997.     m_Size = -1;
  1998.     return status;
  1999. }
  2002. #if !defined(HAVE_MADVISE)
  2004. bool CMemoryFile::MemMapAdviseAddr(void*, size_t, EMemMapAdvise) {
  2005.     return true;
  2006. }
  2007. bool CMemoryFile::MemMapAdvise(EMemMapAdvise) {
  2008.     return true;
  2009. }
  2011. #else  /* HAVE_MADVISE */
  2013. bool CMemoryFile::MemMapAdviseAddr(void* addr, size_t len,
  2014.                                    EMemMapAdvise advise)
  2015. {
  2016.     int adv;
  2017.     if (!addr || !len) {
  2018.         return false;
  2019.     }
  2020.     switch (advise) {
  2021.     case eMMA_Random:
  2022.         adv = MADV_RANDOM;     break;
  2023.     case eMMA_Sequential:
  2024.         adv = MADV_SEQUENTIAL; break;
  2025.     case eMMA_WillNeed:
  2026.         adv = MADV_WILLNEED;   break;
  2027.     case eMMA_DontNeed:
  2028.         adv = MADV_DONTNEED;   break;
  2029.     default:
  2030.         adv = MADV_NORMAL;
  2031.     }
  2032.     // Conversion type of "addr" to char* -- Sun Solaris fix
  2033.     return madvise((char*)addr, len, adv) == 0;
  2034. }
  2037. bool CMemoryFile::MemMapAdvise(EMemMapAdvise advise)
  2038. {
  2039.     if (m_DataPtr  &&   m_Size > 0) {
  2040.         return MemMapAdviseAddr(m_DataPtr, m_Size, advise);
  2041.     } else {
  2042.         return false;
  2043.     }
  2044. }
  2046. #endif  /* HAVE_MADVISE */
  2049. END_NCBI_SCOPE
  2052. /*
  2053.  * ===========================================================================
  2054.  * $Log: ncbifile.cpp,v $
  2055.  * Revision 1000.5  2004/06/01 19:09:09  gouriano
  2056.  * PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.78
  2057.  *
  2058.  * Revision 1.78  2004/05/18 16:51:34  ivanov
  2059.  * Added CDir::GetTmpDir()
  2060.  *
  2061.  * Revision 1.77  2004/05/14 13:59:27  gorelenk
  2062.  * Added include of ncbi_pch.hpp
  2063.  *
  2064.  * Revision 1.76  2004/04/29 15:14:34  kuznets
  2065.  * + Generic FindFile algorithm capable of recursive searches
  2066.  * CDir::GetEntries received additional parameter to ignore self
  2067.  * recursive directory entries (".", "..")
  2068.  *
  2069.  * Revision 1.75  2004/04/28 19:04:29  ucko
  2070.  * Give GetType(), IsFile(), and IsDir() an optional EFollowLinks
  2071.  * parameter (currently only honored on Unix).
  2072.  *
  2073.  * Revision 1.74  2004/04/28 15:56:49  ivanov
  2074.  * CDirEntry::GetType(): fixed bug with incorrect entry type determination
  2075.  * on some platforms
  2076.  *
  2077.  * Revision 1.73  2004/04/21 11:24:53  ivanov
  2078.  * Define s_StdGetTmpName() for all platforms except NCBI_OS_UNIX
  2079.  *
  2080.  * Revision 1.72  2004/03/17 15:39:54  ivanov
  2081.  * CFile:: Fixed possible race condition concerned with temporary file name
  2082.  * generation. Added ETmpFileCreationMode enum. Fixed GetTmpName[Ex] and
  2083.  * CreateTmpFile[Ex] class methods.
  2084.  *
  2085.  * Revision 1.71  2004/03/05 12:26:43  ivanov
  2086.  * Moved CDirEntry::MatchesMask() to NStr class.
  2087.  *
  2088.  * Revision 1.70  2004/02/12 19:50:34  ivanov
  2089.  * Fixed CDirEntry::DeleteTrailingPathSeparator and CDir::CreatePath()
  2090.  * to avoid creating empty directories with disk name in the case if
  2091.  * specified path contains it.
  2092.  *
  2093.  * Revision 1.69  2004/02/11 20:49:57  gorelenk
  2094.  * Implemented case-insensitivity of CreateRelativePath on NCBI_OS_MSWIN.
  2095.  *
  2096.  * Revision 1.68  2004/02/11 20:30:21  gorelenk
  2097.  * Added case-insensitive test of root dirs inside CreateRelativePath.
  2098.  *
  2099.  * Revision 1.67  2004/01/07 13:58:28  ucko
  2100.  * Add missing first argument to string constructor in s_StripDir.
  2101.  *
  2102.  * Revision 1.66  2004/01/05 21:40:54  gorelenk
  2103.  * += Exception throwing in CDirEntry::CreateRelativePath()
  2104.  *
  2105.  * Revision 1.65  2004/01/05 20:04:05  gorelenk
  2106.  * + CDirEntry::CreateRelativePath()
  2107.  *
  2108.  * Revision 1.64  2003/11/28 16:51:48  ivanov
  2109.  * Fixed CDirEntry::SetTime() to set current time if parameter is empty
  2110.  *
  2111.  * Revision 1.63  2003/11/28 16:22:42  ivanov
  2112.  * + CDirEntry::SetTime()
  2113.  *
  2114.  * Revision 1.62  2003/11/05 15:36:23  kuznets
  2115.  * Implemented new variant of CDir::GetEntries()
  2116.  *
  2117.  * Revision 1.61  2003/10/23 12:10:51  ucko
  2118.  * Use AutoPtr with CDeleter rather than auto_ptr, which is *not*
  2119.  * guaranteed to be appropriate for malloc()ed memory.
  2120.  *
  2121.  * Revision 1.60  2003/10/22 13:25:47  ivanov
  2122.  * GetTmpName[Ex]:  replaced tempnam() with mkstemp() for UNIX
  2123.  *
  2124.  * Revision 1.59  2003/10/08 15:45:09  ivanov
  2125.  * Added CDirEntry::DeleteTrailingPathSeparator()
  2126.  *
  2127.  * Revision 1.58  2003/10/01 14:32:09  ucko
  2128.  * +EFollowLinks
  2129.  *
  2130.  * Revision 1.57  2003/09/30 15:08:51  ucko
  2131.  * Reworked CDirEntry::NormalizePath, which now handles .. correctly in
  2132.  * all cases and optionally resolves symlinks (on Unix).
  2133.  *
  2134.  * Revision 1.56  2003/09/17 20:55:02  ivanov
  2135.  * NormalizePath: added more processing for MS Windows paths
  2136.  *
  2137.  * Revision 1.55  2003/09/16 18:54:26  ivanov
  2138.  * NormalizePath(): added replacing double dir separators with single one
  2139.  *
  2140.  * Revision 1.54  2003/09/16 16:03:00  ivanov
  2141.  * MakePath():  don't add separator to directory name if it is an empty string
  2142.  *
  2143.  * Revision 1.53  2003/09/16 15:17:16  ivanov
  2144.  * + CDirEntry::NormalizePath()
  2145.  *
  2146.  * Revision 1.52  2003/08/29 16:54:28  ivanov
  2147.  * GetTmpName(): use tempname() instead tmpname()
  2148.  *
  2149.  * Revision 1.51  2003/08/21 20:32:48  ivanov
  2150.  * CDirEntry::GetType(): use lstat() instead stat() on UNIX
  2151.  *
  2152.  * Revision 1.50  2003/08/08 13:37:17  siyan
  2153.  * Changed GetTmpNameExt to GetTmpNameEx in CFile, as this is the more
  2154.  * appropriate name.
  2155.  *
  2156.  * Revision 1.49  2003/06/18 18:57:43  rsmith
  2157.  * alternate implementation of GetTmpNameExt replacing tempnam with mktemp for
  2158.  * library missing tempnam.
  2159.  *
  2160.  * Revision 1.48  2003/05/29 17:21:04  gouriano
  2161.  * added CreatePath() which creates directories recursively
  2162.  *
  2163.  * Revision 1.47  2003/04/11 14:04:49  ivanov
  2164.  * Fixed CDirEntry::GetMode (Mac OS) - store a mode only for a notzero pointers.
  2165.  * Fixed CDir::GetEntries -- do not try to close a dir handle if it was
  2166.  * not opened.
  2167.  *
  2168.  * Revision 1.46  2003/04/04 16:02:37  lavr
  2169.  * Lines wrapped at 79th column; some minor reformatting
  2170.  *
  2171.  * Revision 1.45  2003/04/03 14:15:48  rsmith
  2172.  * combine pp symbols NCBI_COMPILER_METROWERKS & _MSL_USING_MW_C_HEADERS
  2173.  * into NCBI_COMPILER_MW_MSL
  2174.  *
  2175.  * Revision 1.44  2003/04/02 16:22:34  rsmith
  2176.  * clean up metrowerks ifdefs.
  2177.  *
  2178.  * Revision 1.43  2003/04/02 13:29:29  rsmith
  2179.  * include ncbi_mslextras.h when compiling with MSL libs in Codewarrior.
  2180.  *
  2181.  * Revision 1.42  2003/03/10 18:57:08  kuznets
  2182.  * iterate->ITERATE
  2183.  *
  2184.  * Revision 1.41  2003/02/28 21:06:02  ivanov
  2185.  * Added close() call to CTmpStream destructor before the file deleting.
  2186.  *
  2187.  * Revision 1.40  2003/02/14 19:30:50  ivanov
  2188.  * Added mode ios::trunc by default for files creates in CFile::CreateTmpFile().
  2189.  * Get read of some warnings - initialize variables in CMemoryFile::x_Map().
  2190.  *
  2191.  * Revision 1.39  2003/02/06 16:14:28  ivanov
  2192.  * CMemomyFile::x_Map(): changed file access attribute from O_RDWR to
  2193.  * O_RDONLY in case of private sharing.
  2194.  *
  2195.  * Revision 1.38  2003/02/05 22:07:15  ivanov
  2196.  * Added protect and sharing parameters to the CMemoryFile constructor.
  2197.  * Added CMemoryFile::Flush() method.
  2198.  *
  2199.  * Revision 1.37  2003/01/16 13:27:56  dicuccio
  2200.  * Added CDir::GetCwd()
  2201.  *
  2202.  * Revision 1.36  2002/11/05 15:46:49  dicuccio
  2203.  * Changed CDir::GetEntries() to store fully qualified path names - this permits
  2204.  * CDirEntry::GetType() to work on files outside of the local directory.
  2205.  *
  2206.  * Revision 1.35  2002/10/01 17:23:57  gouriano
  2207.  * more fine-tuning of ConvertToOSPath
  2208.  *
  2209.  * Revision 1.34  2002/10/01 17:02:53  gouriano
  2210.  * minor modification of ConvertToOSPath
  2211.  *
  2212.  * Revision 1.33  2002/10/01 14:18:45  gouriano
  2213.  * "optimize" result of ConvertToOSPath
  2214.  *
  2215.  * Revision 1.32  2002/09/19 20:05:42  vasilche
  2216.  * Safe initialization of static mutexes
  2217.  *
  2218.  * Revision 1.31  2002/09/17 20:44:58  lavr
  2219.  * Add comment in unreachable return from CDirEntry::MatchesMask()
  2220.  *
  2221.  * Revision 1.30  2002/09/05 18:35:38  vakatov
  2222.  * Formal code rearrangement to get rid of comp.warnings;  some nice-ification
  2223.  *
  2224.  * Revision 1.29  2002/07/18 20:22:59  lebedev
  2225.  * NCBI_OS_MAC: fcntl.h added
  2226.  *
  2227.  * Revision 1.28  2002/07/15 18:17:24  gouriano
  2228.  * renamed CNcbiException and its descendents
  2229.  *
  2230.  * Revision 1.27  2002/07/11 19:28:30  ivanov
  2231.  * Removed test stuff from MemMapAdvise[Addr]
  2232.  *
  2233.  * Revision 1.26  2002/07/11 19:21:30  ivanov
  2234.  * Added CMemoryFile::MemMapAdvise[Addr]()
  2235.  *
  2236.  * Revision 1.25  2002/07/11 14:18:27  gouriano
  2237.  * exceptions replaced by CNcbiException-type ones
  2238.  *
  2239.  * Revision 1.24  2002/06/07 16:11:37  ivanov
  2240.  * Chenget GetTime() -- using CTime instead time_t, modification time
  2241.  * by default
  2242.  *
  2243.  * Revision 1.23  2002/06/07 15:21:06  ivanov
  2244.  * Added CDirEntry::GetTime()
  2245.  *
  2246.  * Revision 1.22  2002/05/01 22:59:00  vakatov
  2247.  * A couple of (size_t) type casts to avoid compiler warnings in 64-bit
  2248.  *
  2249.  * Revision 1.21  2002/04/11 21:08:02  ivanov
  2250.  * CVS log moved to end of the file
  2251.  *
  2252.  * Revision 1.20  2002/04/01 18:49:54  ivanov
  2253.  * Added class CMemoryFile. Added including <windows.h> under MS Windows
  2254.  *
  2255.  * Revision 1.19  2002/03/25 17:08:17  ucko
  2256.  * Centralize treatment of Cygwin as Unix rather than Windows in configure.
  2257.  *
  2258.  * Revision 1.18  2002/03/22 20:00:01  ucko
  2259.  * Tweak to work on Cygwin.  (Use Unix rather than MSWIN code).
  2260.  *
  2261.  * Revision 1.17  2002/02/07 21:05:47  kans
  2262.  * implemented GetHome (FindFolder kPreferencesFolderType) for Mac
  2263.  *
  2264.  * Revision 1.16  2002/01/24 22:18:02  ivanov
  2265.  * Changed CDirEntry::Remove() and CDir::Remove()
  2266.  *
  2267.  * Revision 1.15  2002/01/22 21:21:09  ivanov
  2268.  * Fixed typing error
  2269.  *
  2270.  * Revision 1.14  2002/01/22 19:27:39  ivanov
  2271.  * Added realization ConcatPathEx()
  2272.  *
  2273.  * Revision 1.13  2002/01/20 06:13:34  vakatov
  2274.  * Fixed warning;  formatted the source code
  2275.  *
  2276.  * Revision 1.12  2002/01/10 16:46:36  ivanov
  2277.  * Added CDir::GetHome() and some CDirEntry:: path processing functions
  2278.  *
  2279.  * Revision 1.11  2001/12/26 21:21:05  ucko
  2280.  * Conditionalize deletion of m_FSS on NCBI_OS_MAC.
  2281.  *
  2282.  * Revision 1.10  2001/12/26 20:58:22  juran
  2283.  * Use an FSSpec* member instead of an FSSpec, so a forward declaration can
  2284.  * be used.
  2285.  * Add copy constructor and assignment operator for CDirEntry on Mac OS,
  2286.  * thus avoiding memberwise copy which would blow up upon deleting the
  2287.  * pointer twice.
  2288.  *
  2289.  * Revision 1.9  2001/12/18 21:36:38  juran
  2290.  * Remove unneeded Mac headers.
  2291.  * (Required functions copied to ncbi_os_mac.cpp)
  2292.  * MoveRename PStr to PString in ncbi_os_mac.hpp.
  2293.  * Don't use MoreFiles xxxCompat functions.  They're for System 6.
  2294.  * Don't use global scope operator on functions copied into NCBI scope.
  2295.  *
  2296.  * Revision 1.8  2001/11/19 23:38:44  vakatov
  2297.  * Fix to compile with SUN WorkShop (and maybe other) compiler(s)
  2298.  *
  2299.  * Revision 1.7  2001/11/19 18:10:13  juran
  2300.  * Whitespace.
  2301.  *
  2302.  * Revision 1.6  2001/11/15 16:34:12  ivanov
  2303.  * Moved from util to corelib
  2304.  *
  2305.  * Revision 1.5  2001/11/06 14:34:11  ivanov
  2306.  * Fixed compile errors in CDir::Contents() under MS Windows
  2307.  *
  2308.  * Revision 1.4  2001/11/01 21:02:25  ucko
  2309.  * Fix to work on non-MacOS platforms again.
  2310.  *
  2311.  * Revision 1.3  2001/11/01 20:06:48  juran
  2312.  * Replace directory streams with Contents() method.
  2313.  * Implement and test Mac OS platform.
  2314.  *
  2315.  * Revision 1.2  2001/09/19 16:22:18  ucko
  2316.  * S_IFDOOR is nonportable; make sure it exists before using it.
  2317.  * Fix type of second argument to CTmpStream's constructor (caught by gcc 3).
  2318.  *
  2319.  * Revision 1.1  2001/09/19 13:06:09  ivanov
  2320.  * Initial revision
  2321.  *
  2322.  * ===========================================================================
  2323.  */