CMakeLua/Source/cmGeneratedFileStream.cxx

   1 /*=========================================================================
   2
   3   Program:   CMake - Cross-Platform Makefile Generator
   4   Module:    $RCSfile: cmGeneratedFileStream.cxx,v $
   5   Language:  C++
   6   Date:      $Date: 2007/11/16 12:01:58 $
   7   Version:   $Revision: 1.19 $
   8
   9   Copyright (c) 2002 Kitware, Inc., Insight Consortium.  All rights reserved.
  10   See Copyright.txt or http://www.cmake.org/HTML/Copyright.html for details.
  11
  12      This software is distributed WITHOUT ANY WARRANTY; without even
  13      the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  14      PURPOSE.  See the above copyright notices for more information.
  15
  16 =========================================================================*/
  17 #include "cmGeneratedFileStream.h"
  18
  19 #include "cmSystemTools.h"
  20
  21 // Includes needed for implementation of RenameFile.  This is not in
  22 // system tools because it is not implemented robustly enough to move
  23 // files across directories.
  24 #ifdef _WIN32
  25 # include <windows.h>
  26 # include <sys/stat.h>
  27 #endif
  28
  29 #if defined(CMAKE_BUILD_WITH_CMAKE)
  30 # include <cm_zlib.h>
  31 #endif
  32
  33 //----------------------------------------------------------------------------
  34 cmGeneratedFileStream::cmGeneratedFileStream():
  35   cmGeneratedFileStreamBase(), Stream()
  36 {
  37 }
  38
  39 //----------------------------------------------------------------------------
  40 cmGeneratedFileStream::cmGeneratedFileStream(const char* name, bool quiet):
  41   cmGeneratedFileStreamBase(name),
  42   Stream(TempName.c_str())
  43 {
  44   // Check if the file opened.
  45   if(!*this && !quiet)
  46     {
  47     cmSystemTools::Error("Cannot open file for write: ",
  48                          this->TempName.c_str());
  49     cmSystemTools::ReportLastSystemError("");
  50     }
  51 }
  52
  53 //----------------------------------------------------------------------------
  54 cmGeneratedFileStream::~cmGeneratedFileStream()
  55 {
  56   // This is the first destructor called.  Check the status of the
  57   // stream and give the information to the private base.  Next the
  58   // stream will be destroyed which will close the temporary file.
  59   // Finally the base destructor will be called to replace the
  60   // destination file.
  61   this->Okay = (*this)?true:false;
  62 }
  63
  64 //----------------------------------------------------------------------------
  65 cmGeneratedFileStream&
  66 cmGeneratedFileStream::Open(const char* name, bool quiet, bool binaryFlag)
  67 {
  68   // Store the file name and construct the temporary file name.
  69   this->cmGeneratedFileStreamBase::Open(name);
  70
  71   // Open the temporary output file.
  72   if ( binaryFlag )
  73     {
  74     this->Stream::open(this->TempName.c_str(),
  75                        std::ios::out | std::ios::binary);
  76     }
  77   else
  78     {
  79     this->Stream::open(this->TempName.c_str(), std::ios::out);
  80     }
  81
  82   // Check if the file opened.
  83   if(!*this && !quiet)
  84     {
  85     cmSystemTools::Error("Cannot open file for write: ",
  86                          this->TempName.c_str());
  87     cmSystemTools::ReportLastSystemError("");
  88     }
  89   return *this;
  90 }
  91
  92 //----------------------------------------------------------------------------
  93 bool
  94 cmGeneratedFileStream::Close()
  95 {
  96   // Save whether the temporary output file is valid before closing.
  97   this->Okay = (*this)?true:false;
  98
  99   // Close the temporary output file.
 100   this->Stream::close();
 101
 102   // Remove the temporary file (possibly by renaming to the real file).
 103   return this->cmGeneratedFileStreamBase::Close();
 104 }
 105
 106 //----------------------------------------------------------------------------
 107 void cmGeneratedFileStream::SetCopyIfDifferent(bool copy_if_different)
 108 {
 109   this->CopyIfDifferent = copy_if_different;
 110 }
 111
 112 //----------------------------------------------------------------------------
 113 void cmGeneratedFileStream::SetCompression(bool compression)
 114 {
 115   this->Compress = compression;
 116 }
 117
 118 //----------------------------------------------------------------------------
 119 void cmGeneratedFileStream::SetCompressionExtraExtension(bool ext)
 120 {
 121   this->CompressExtraExtension = ext;
 122 }
 123
 124 //----------------------------------------------------------------------------
 125 cmGeneratedFileStreamBase::cmGeneratedFileStreamBase():
 126   Name(),
 127   TempName(),
 128   CopyIfDifferent(false),
 129   Okay(false),
 130   Compress(false),
 131   CompressExtraExtension(true)
 132 {
 133 }
 134
 135 //----------------------------------------------------------------------------
 136 cmGeneratedFileStreamBase::cmGeneratedFileStreamBase(const char* name):
 137   Name(),
 138   TempName(),
 139   CopyIfDifferent(false),
 140   Okay(false),
 141   Compress(false),
 142   CompressExtraExtension(true)
 143 {
 144   this->Open(name);
 145 }
 146
 147 //----------------------------------------------------------------------------
 148 cmGeneratedFileStreamBase::~cmGeneratedFileStreamBase()
 149 {
 150   this->Close();
 151 }
 152
 153 //----------------------------------------------------------------------------
 154 void cmGeneratedFileStreamBase::Open(const char* name)
 155 {
 156   // Save the original name of the file.
 157   this->Name = name;
 158
 159   // Create the name of the temporary file.
 160   this->TempName = name;
 161   this->TempName += ".tmp";
 162
 163   // Make sure the temporary file that will be used is not present.
 164   cmSystemTools::RemoveFile(this->TempName.c_str());
 165
 166   std::string dir = cmSystemTools::GetFilenamePath(this->TempName);
 167   cmSystemTools::MakeDirectory(dir.c_str());
 168 }
 169
 170 //----------------------------------------------------------------------------
 171 bool cmGeneratedFileStreamBase::Close()
 172 {
 173   bool replaced = false;
 174
 175   std::string resname = this->Name;
 176   if ( this->Compress && this->CompressExtraExtension )
 177     {
 178     resname += ".gz";
 179     }
 180
 181   // Only consider replacing the destination file if no error
 182   // occurred.
 183   if(!this->Name.empty() &&
 184     this->Okay &&
 185     (!this->CopyIfDifferent ||
 186      cmSystemTools::FilesDiffer(this->TempName.c_str(), resname.c_str())))
 187     {
 188     // The destination is to be replaced.  Rename the temporary to the
 189     // destination atomically.
 190     if ( this->Compress )
 191       {
 192       std::string gzname = this->TempName + ".temp.gz";
 193       if ( this->CompressFile(this->TempName.c_str(), gzname.c_str()) )
 194         {
 195         this->RenameFile(gzname.c_str(), resname.c_str());
 196         }
 197       cmSystemTools::RemoveFile(gzname.c_str());
 198       }
 199     else
 200       {
 201       this->RenameFile(this->TempName.c_str(), resname.c_str());
 202       }
 203
 204     replaced = true;
 205     }
 206
 207   // Else, the destination was not replaced.
 208   //
 209   // Always delete the temporary file. We never want it to stay around.
 210   cmSystemTools::RemoveFile(this->TempName.c_str());
 211
 212   return replaced;
 213 }
 214
 215 //----------------------------------------------------------------------------
 216 #ifdef CMAKE_BUILD_WITH_CMAKE
 217 int cmGeneratedFileStreamBase::CompressFile(const char* oldname,
 218                                             const char* newname)
 219 {
 220   gzFile gf = gzopen(newname, "w");
 221   if ( !gf )
 222     {
 223     return 0;
 224     }
 225   FILE* ifs = fopen(oldname, "r");
 226   if ( !ifs )
 227     {
 228     return 0;
 229     }
 230   size_t res;
 231   const size_t BUFFER_SIZE = 1024;
 232   char buffer[BUFFER_SIZE];
 233   while ( (res = fread(buffer, 1, BUFFER_SIZE, ifs)) > 0 )
 234     {
 235     if ( !gzwrite(gf, buffer, static_cast<int>(res)) )
 236       {
 237       fclose(ifs);
 238       gzclose(gf);
 239       return 0;
 240       }
 241     }
 242   fclose(ifs);
 243   gzclose(gf);
 244   return 1;
 245 }
 246 #else
 247 int cmGeneratedFileStreamBase::CompressFile(const char*, const char*)
 248 {
 249   return 0;
 250 }
 251 #endif
 252
 253 //----------------------------------------------------------------------------
 254 int cmGeneratedFileStreamBase::RenameFile(const char* oldname,
 255                                           const char* newname)
 256 {
 257 #ifdef _WIN32
 258   /* On Windows the move functions will not replace existing files.
 259      Check if the destination exists.  */
 260   struct stat newFile;
 261   if(stat(newname, &newFile) == 0)
 262     {
 263     /* The destination exists.  We have to replace it carefully.  The
 264        MoveFileEx function does what we need but is not available on
 265        Win9x.  */
 266     OSVERSIONINFO osv;
 267     DWORD attrs;
 268
 269     /* Make sure the destination is not read only.  */
 270     attrs = GetFileAttributes(newname);
 271     if(attrs & FILE_ATTRIBUTE_READONLY)
 272       {
 273       SetFileAttributes(newname, attrs & ~FILE_ATTRIBUTE_READONLY);
 274       }
 275
 276     /* Check the windows version number.  */
 277     osv.dwOSVersionInfoSize = sizeof(osv);
 278     GetVersionEx(&osv);
 279     if(osv.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS)
 280       {
 281       /* This is Win9x.  There is no MoveFileEx implementation.  We
 282          cannot quite rename the file atomically.  Just delete the
 283          destination and then move the file.  */
 284       DeleteFile(newname);
 285       return MoveFile(oldname, newname);
 286       }
 287     else
 288       {
 289       /* This is not Win9x.  Use the MoveFileEx implementation.  */
 290       return MoveFileEx(oldname, newname, MOVEFILE_REPLACE_EXISTING);
 291       }
 292     }
 293   else
 294     {
 295     /* The destination does not exist.  Just move the file.  */
 296     return MoveFile(oldname, newname);
 297     }
 298 #else
 299   /* On UNIX we have an OS-provided call to do this atomically.  */
 300   return rename(oldname, newname) == 0;
 301 #endif
 302 }
 303
 304 //----------------------------------------------------------------------------
 305 void cmGeneratedFileStream::SetName(const char* fname)
 306 {
 307   if ( !fname )
 308     {
 309     this->Name = "";
 310     return;
 311     }
 312   this->Name = fname;
 313 }