mirror of
https://github.com/reactos/CMake.git
synced 2024-11-24 20:19:53 +00:00
314 lines
8.8 KiB
C++
314 lines
8.8 KiB
C++
/*=========================================================================
|
|
|
|
Program: CMake - Cross-Platform Makefile Generator
|
|
Module: $RCSfile$
|
|
Language: C++
|
|
Date: $Date$
|
|
Version: $Revision$
|
|
|
|
Copyright (c) 2002 Kitware, Inc., Insight Consortium. All rights reserved.
|
|
See Copyright.txt or http://www.cmake.org/HTML/Copyright.html for details.
|
|
|
|
This software is distributed WITHOUT ANY WARRANTY; without even
|
|
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
|
|
PURPOSE. See the above copyright notices for more information.
|
|
|
|
=========================================================================*/
|
|
#include "cmGeneratedFileStream.h"
|
|
|
|
#include "cmSystemTools.h"
|
|
|
|
// Includes needed for implementation of RenameFile. This is not in
|
|
// system tools because it is not implemented robustly enough to move
|
|
// files across directories.
|
|
#ifdef _WIN32
|
|
# include <windows.h>
|
|
# include <sys/stat.h>
|
|
#endif
|
|
|
|
#if defined(CMAKE_BUILD_WITH_CMAKE)
|
|
# include <cm_zlib.h>
|
|
#endif
|
|
|
|
//----------------------------------------------------------------------------
|
|
cmGeneratedFileStream::cmGeneratedFileStream():
|
|
cmGeneratedFileStreamBase(), Stream()
|
|
{
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
cmGeneratedFileStream::cmGeneratedFileStream(const char* name, bool quiet):
|
|
cmGeneratedFileStreamBase(name),
|
|
Stream(TempName.c_str())
|
|
{
|
|
// Check if the file opened.
|
|
if(!*this && !quiet)
|
|
{
|
|
cmSystemTools::Error("Cannot open file for write: ",
|
|
this->TempName.c_str());
|
|
cmSystemTools::ReportLastSystemError("");
|
|
}
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
cmGeneratedFileStream::~cmGeneratedFileStream()
|
|
{
|
|
// This is the first destructor called. Check the status of the
|
|
// stream and give the information to the private base. Next the
|
|
// stream will be destroyed which will close the temporary file.
|
|
// Finally the base destructor will be called to replace the
|
|
// destination file.
|
|
this->Okay = (*this)?true:false;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
cmGeneratedFileStream&
|
|
cmGeneratedFileStream::Open(const char* name, bool quiet, bool binaryFlag)
|
|
{
|
|
// Store the file name and construct the temporary file name.
|
|
this->cmGeneratedFileStreamBase::Open(name);
|
|
|
|
// Open the temporary output file.
|
|
if ( binaryFlag )
|
|
{
|
|
this->Stream::open(this->TempName.c_str(),
|
|
std::ios::out | std::ios::binary);
|
|
}
|
|
else
|
|
{
|
|
this->Stream::open(this->TempName.c_str(), std::ios::out);
|
|
}
|
|
|
|
// Check if the file opened.
|
|
if(!*this && !quiet)
|
|
{
|
|
cmSystemTools::Error("Cannot open file for write: ",
|
|
this->TempName.c_str());
|
|
cmSystemTools::ReportLastSystemError("");
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
cmGeneratedFileStream::Close()
|
|
{
|
|
// Save whether the temporary output file is valid before closing.
|
|
this->Okay = (*this)?true:false;
|
|
|
|
// Close the temporary output file.
|
|
this->Stream::close();
|
|
|
|
// Remove the temporary file (possibly by renaming to the real file).
|
|
return this->cmGeneratedFileStreamBase::Close();
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
void cmGeneratedFileStream::SetCopyIfDifferent(bool copy_if_different)
|
|
{
|
|
this->CopyIfDifferent = copy_if_different;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
void cmGeneratedFileStream::SetCompression(bool compression)
|
|
{
|
|
this->Compress = compression;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
void cmGeneratedFileStream::SetCompressionExtraExtension(bool ext)
|
|
{
|
|
this->CompressExtraExtension = ext;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
cmGeneratedFileStreamBase::cmGeneratedFileStreamBase():
|
|
Name(),
|
|
TempName(),
|
|
CopyIfDifferent(false),
|
|
Okay(false),
|
|
Compress(false),
|
|
CompressExtraExtension(true)
|
|
{
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
cmGeneratedFileStreamBase::cmGeneratedFileStreamBase(const char* name):
|
|
Name(),
|
|
TempName(),
|
|
CopyIfDifferent(false),
|
|
Okay(false),
|
|
Compress(false),
|
|
CompressExtraExtension(true)
|
|
{
|
|
this->Open(name);
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
cmGeneratedFileStreamBase::~cmGeneratedFileStreamBase()
|
|
{
|
|
this->Close();
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
void cmGeneratedFileStreamBase::Open(const char* name)
|
|
{
|
|
// Save the original name of the file.
|
|
this->Name = name;
|
|
|
|
// Create the name of the temporary file.
|
|
this->TempName = name;
|
|
this->TempName += ".tmp";
|
|
|
|
// Make sure the temporary file that will be used is not present.
|
|
cmSystemTools::RemoveFile(this->TempName.c_str());
|
|
|
|
std::string dir = cmSystemTools::GetFilenamePath(this->TempName);
|
|
cmSystemTools::MakeDirectory(dir.c_str());
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool cmGeneratedFileStreamBase::Close()
|
|
{
|
|
bool replaced = false;
|
|
|
|
std::string resname = this->Name;
|
|
if ( this->Compress && this->CompressExtraExtension )
|
|
{
|
|
resname += ".gz";
|
|
}
|
|
|
|
// Only consider replacing the destination file if no error
|
|
// occurred.
|
|
if(!this->Name.empty() &&
|
|
this->Okay &&
|
|
(!this->CopyIfDifferent ||
|
|
cmSystemTools::FilesDiffer(this->TempName.c_str(), resname.c_str())))
|
|
{
|
|
// The destination is to be replaced. Rename the temporary to the
|
|
// destination atomically.
|
|
if ( this->Compress )
|
|
{
|
|
std::string gzname = this->TempName + ".temp.gz";
|
|
if ( this->CompressFile(this->TempName.c_str(), gzname.c_str()) )
|
|
{
|
|
this->RenameFile(gzname.c_str(), resname.c_str());
|
|
}
|
|
cmSystemTools::RemoveFile(gzname.c_str());
|
|
}
|
|
else
|
|
{
|
|
this->RenameFile(this->TempName.c_str(), resname.c_str());
|
|
}
|
|
|
|
replaced = true;
|
|
}
|
|
|
|
// Else, the destination was not replaced.
|
|
//
|
|
// Always delete the temporary file. We never want it to stay around.
|
|
cmSystemTools::RemoveFile(this->TempName.c_str());
|
|
|
|
return replaced;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
#ifdef CMAKE_BUILD_WITH_CMAKE
|
|
int cmGeneratedFileStreamBase::CompressFile(const char* oldname,
|
|
const char* newname)
|
|
{
|
|
gzFile gf = gzopen(newname, "w");
|
|
if ( !gf )
|
|
{
|
|
return 0;
|
|
}
|
|
FILE* ifs = fopen(oldname, "r");
|
|
if ( !ifs )
|
|
{
|
|
return 0;
|
|
}
|
|
size_t res;
|
|
const size_t BUFFER_SIZE = 1024;
|
|
char buffer[BUFFER_SIZE];
|
|
while ( (res = fread(buffer, 1, BUFFER_SIZE, ifs)) > 0 )
|
|
{
|
|
if ( !gzwrite(gf, buffer, static_cast<int>(res)) )
|
|
{
|
|
fclose(ifs);
|
|
gzclose(gf);
|
|
return 0;
|
|
}
|
|
}
|
|
fclose(ifs);
|
|
gzclose(gf);
|
|
return 1;
|
|
}
|
|
#else
|
|
int cmGeneratedFileStreamBase::CompressFile(const char*, const char*)
|
|
{
|
|
return 0;
|
|
}
|
|
#endif
|
|
|
|
//----------------------------------------------------------------------------
|
|
int cmGeneratedFileStreamBase::RenameFile(const char* oldname,
|
|
const char* newname)
|
|
{
|
|
#ifdef _WIN32
|
|
/* On Windows the move functions will not replace existing files.
|
|
Check if the destination exists. */
|
|
struct stat newFile;
|
|
if(stat(newname, &newFile) == 0)
|
|
{
|
|
/* The destination exists. We have to replace it carefully. The
|
|
MoveFileEx function does what we need but is not available on
|
|
Win9x. */
|
|
OSVERSIONINFO osv;
|
|
DWORD attrs;
|
|
|
|
/* Make sure the destination is not read only. */
|
|
attrs = GetFileAttributes(newname);
|
|
if(attrs & FILE_ATTRIBUTE_READONLY)
|
|
{
|
|
SetFileAttributes(newname, attrs & ~FILE_ATTRIBUTE_READONLY);
|
|
}
|
|
|
|
/* Check the windows version number. */
|
|
osv.dwOSVersionInfoSize = sizeof(osv);
|
|
GetVersionEx(&osv);
|
|
if(osv.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS)
|
|
{
|
|
/* This is Win9x. There is no MoveFileEx implementation. We
|
|
cannot quite rename the file atomically. Just delete the
|
|
destination and then move the file. */
|
|
DeleteFile(newname);
|
|
return MoveFile(oldname, newname);
|
|
}
|
|
else
|
|
{
|
|
/* This is not Win9x. Use the MoveFileEx implementation. */
|
|
return MoveFileEx(oldname, newname, MOVEFILE_REPLACE_EXISTING);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/* The destination does not exist. Just move the file. */
|
|
return MoveFile(oldname, newname);
|
|
}
|
|
#else
|
|
/* On UNIX we have an OS-provided call to do this atomically. */
|
|
return rename(oldname, newname) == 0;
|
|
#endif
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
void cmGeneratedFileStream::SetName(const char* fname)
|
|
{
|
|
if ( !fname )
|
|
{
|
|
this->Name = "";
|
|
return;
|
|
}
|
|
this->Name = fname;
|
|
}
|