CMake/Source/cmFileCommand.cxx

641 lines
17 KiB
C++
Raw Normal View History

/*=========================================================================
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 "cmFileCommand.h"
2003-07-08 22:18:17 +04:00
#include "cmGlob.h"
#include <sys/types.h>
#include <sys/stat.h>
// cmLibraryCommand
bool cmFileCommand::InitialPass(std::vector<std::string> const& args)
{
if(args.size() < 2 )
{
this->SetError("must be called with at least two arguments.");
return false;
}
std::string subCommand = args[0];
if ( subCommand == "WRITE" )
{
return this->HandleWriteCommand(args, false);
}
else if ( subCommand == "APPEND" )
{
return this->HandleWriteCommand(args, true);
}
else if ( subCommand == "READ" )
{
return this->HandleReadCommand(args);
}
2003-07-08 22:18:17 +04:00
else if ( subCommand == "GLOB" )
{
2003-07-14 17:15:13 +04:00
return this->HandleGlobCommand(args, false);
}
else if ( subCommand == "GLOB_RECURSE" )
{
return this->HandleGlobCommand(args, true);
2003-07-08 22:18:17 +04:00
}
else if ( subCommand == "MAKE_DIRECTORY" )
{
return this->HandleMakeDirectoryCommand(args);
}
else if ( subCommand == "INSTALL" )
{
return this->HandleInstallCommand(args);
}
std::string e = "does not recognize sub-command "+subCommand;
this->SetError(e.c_str());
return false;
}
//----------------------------------------------------------------------------
bool cmFileCommand::HandleWriteCommand(std::vector<std::string> const& args,
bool append)
{
std::string message;
std::vector<std::string>::const_iterator i = args.begin();
i++; // Get rid of subcommand
std::string fileName = *i;
2003-07-08 22:18:17 +04:00
if ( !cmsys::SystemTools::FileIsFullPath(i->c_str()) )
{
fileName = m_Makefile->GetCurrentDirectory();
fileName += "/" + *i;
}
i++;
for(;i != args.end(); ++i)
{
message += *i;
}
std::string dir = cmSystemTools::GetFilenamePath(fileName);
cmSystemTools::MakeDirectory(dir.c_str());
std::ofstream file(fileName.c_str(), append?std::ios::app: std::ios::out);
if ( !file )
{
std::string error = "Internal CMake error when trying to open file: ";
error += fileName.c_str();
error += " for writting.";
this->SetError(error.c_str());
return false;
}
file << message;
file.close();
m_Makefile->AddWrittenFile(fileName.c_str());
return true;
}
//----------------------------------------------------------------------------
bool cmFileCommand::HandleReadCommand(std::vector<std::string> const& args)
{
if ( args.size() != 3 )
{
this->SetError("READ must be called with two additional arguments");
2003-07-08 22:18:17 +04:00
return false;
}
std::string fileName = args[1];
2003-07-08 22:18:17 +04:00
if ( !cmsys::SystemTools::FileIsFullPath(args[1].c_str()) )
{
fileName = m_Makefile->GetCurrentDirectory();
fileName += "/" + args[1];
}
std::string variable = args[2];
std::ifstream file(fileName.c_str(), std::ios::in);
if ( !file )
{
std::string error = "Internal CMake error when trying to open file: ";
error += fileName.c_str();
error += " for reading.";
this->SetError(error.c_str());
return false;
}
std::string output;
std::string line;
bool has_newline = false;
while ( cmSystemTools::GetLineFromStream(file, line, &has_newline) )
{
output += line;
if ( has_newline )
{
output += "\n";
}
}
m_Makefile->AddDefinition(variable.c_str(), output.c_str());
return true;
}
2003-07-08 22:18:17 +04:00
//----------------------------------------------------------------------------
2003-07-14 17:15:13 +04:00
bool cmFileCommand::HandleGlobCommand(std::vector<std::string> const& args,
bool recurse)
2003-07-08 22:18:17 +04:00
{
if ( args.size() < 2 )
{
this->SetError("GLOB requires at least a variable name");
return false;
}
#ifdef CMAKE_BUILD_WITH_CMAKE
2003-07-08 22:18:17 +04:00
std::vector<std::string>::const_iterator i = args.begin();
i++; // Get rid of subcommand
std::string variable = *i;
i++;
cmGlob g;
2003-07-14 17:15:13 +04:00
g.SetRecurse(recurse);
2003-07-08 22:18:17 +04:00
std::string output = "";
bool first = true;
for ( ; i != args.end(); ++i )
{
if ( !cmsys::SystemTools::FileIsFullPath(i->c_str()) )
{
std::string expr = m_Makefile->GetCurrentDirectory();
2004-02-06 23:18:55 +03:00
// Handle script mode
if ( expr.size() > 0 )
{
expr += "/" + *i;
g.FindFiles(expr);
}
else
{
g.FindFiles(*i);
}
2003-07-08 22:18:17 +04:00
}
else
{
g.FindFiles(*i);
}
std::vector<std::string>::size_type cc;
std::vector<std::string>& files = g.GetFiles();
for ( cc = 0; cc < files.size(); cc ++ )
{
if ( !first )
{
output += ";";
}
output += files[cc];
first = false;
}
}
m_Makefile->AddDefinition(variable.c_str(), output.c_str());
return true;
#else
(void)recurse;
this->SetError("GLOB is not implemented in the bootstrap CMake");
return false;
#endif
2003-07-08 22:18:17 +04:00
}
//----------------------------------------------------------------------------
2004-02-13 05:44:24 +03:00
bool cmFileCommand::HandleMakeDirectoryCommand(
std::vector<std::string> const& args)
{
if(args.size() < 2 )
{
this->SetError("called with incorrect number of arguments");
return false;
}
std::vector<std::string>::const_iterator i = args.begin();
i++; // Get rid of subcommand
std::string expr;
for ( ; i != args.end(); ++i )
{
const std::string* cdir = &(*i);
if ( !cmsys::SystemTools::FileIsFullPath(i->c_str()) )
{
expr = m_Makefile->GetCurrentDirectory();
expr += "/" + *i;
cdir = &expr;
}
if ( !cmSystemTools::MakeDirectory(cdir->c_str()) )
{
std::string error = "problem creating directory: " + *cdir;
this->SetError(error.c_str());
return false;
}
}
return true;
}
//----------------------------------------------------------------------------
2004-02-13 05:44:24 +03:00
bool cmFileCommand::HandleInstallCommand(
std::vector<std::string> const& args)
{
if ( args.size() < 6 )
{
this->SetError("called with incorrect number of arguments");
return false;
}
std::string destination = "";
std::string stype = "FILES";
const char* build_type = m_Makefile->GetDefinition("BUILD_TYPE");
if ( build_type && strcmp(build_type, ".") == 0 )
{
build_type = 0;
}
if ( build_type && strncmp(build_type, ".\\", 2) == 0 )
{
build_type += 2;
}
2004-06-29 00:39:51 +04:00
const char* debug_postfix
= m_Makefile->GetDefinition("CMAKE_DEBUG_POSTFIX");
if(!debug_postfix)
{
debug_postfix = "";
}
2004-02-13 05:44:24 +03:00
const char* destdir = cmSystemTools::GetEnv("DESTDIR");
std::string extra_dir = "";
2004-02-03 18:53:41 +03:00
int debug = 0;
if ( build_type )
{
extra_dir = build_type;
2004-02-03 19:23:39 +03:00
std::string btype = cmSystemTools::LowerCase(build_type);
if ( strncmp(btype.c_str(), "debug", strlen("debug")) == 0 )
2004-02-03 18:53:41 +03:00
{
debug = 1;
}
}
std::vector<std::string> files;
int itype = cmTarget::INSTALL_FILES;
2004-01-27 00:24:35 +03:00
std::vector<std::string>::size_type i = 0;
i++; // Get rid of subcommand
std::map<cmStdString, const char*> properties;
bool in_files = false;
bool in_properties = false;
bool optional = false;
for ( ; i != args.size(); ++i )
{
const std::string* cstr = &args[i];
if ( *cstr == "DESTINATION" && i < args.size()-1 )
{
i++;
destination = args[i];
in_files = false;
in_properties = false;
}
else if ( *cstr == "TYPE" && i < args.size()-1 )
{
i++;
stype = args[i];
if ( args[i+1] == "OPTIONAL" )
{
i++;
optional = true;
}
in_properties = false;
in_files = false;
}
else if ( *cstr == "PROPERTIES" )
{
in_properties = true;
in_files = false;
}
else if ( *cstr == "FILES" && !in_files)
{
in_files = true;
in_properties = false;
}
else if ( in_properties && i < args.size()-1 )
{
properties[args[i]] = args[i+1].c_str();
i++;
}
else if ( in_files )
{
files.push_back(*cstr);
}
else
{
this->SetError("called with inappropriate arguments");
return false;
}
}
2004-02-13 05:44:24 +03:00
if ( destination.size() < 2 )
{
2004-02-13 05:44:24 +03:00
this->SetError("called with inapropriate arguments. "
"No DESTINATION provided or .");
return false;
}
2004-02-13 05:44:24 +03:00
int destDirLength = 0;
2004-02-13 05:44:24 +03:00
if ( destdir && *destdir )
{
std::string sdestdir = destdir;
cmSystemTools::ConvertToUnixSlashes(sdestdir);
char ch1 = destination[0];
char ch2 = destination[1];
char ch3 = 0;
if ( destination.size() > 2 )
{
ch3 = destination[2];
}
int skip = 0;
if ( ch1 != '/' )
{
int relative = 0;
if ( ( ch1 >= 'a' && ch1 <= 'z' || ch1 >= 'a' && ch1 <= 'z' ) &&
ch2 == ':' )
{
// Assume windows
// let's do some destdir magic:
skip = 2;
if ( ch3 != '/' )
{
relative = 1;
}
}
else
{
relative = 1;
}
if ( relative )
{
// This is relative path on unix or windows. Since we are doing
// destdir, this case does not make sense.
this->SetError("called with relative DESTINATION. This "
"does not make sense when using DESTDIR. Specify "
"absolute path or remove DESTDIR environment variable.");
return false;
}
}
else
{
if ( ch2 == '/' )
{
// looks like a network path.
this->SetError("called with network path DESTINATION. This "
"does not make sense when using DESTDIR. Specify local "
"absolute path or remove DESTDIR environment variable.");
return false;
}
}
destination = sdestdir + (destination.c_str() + skip);
destDirLength = int(sdestdir.size());
2004-02-13 05:44:24 +03:00
}
if ( files.size() == 0 )
{
2004-02-13 05:44:24 +03:00
this->SetError(
"called with inapropriate arguments. No FILES provided.");
return false;
}
if ( stype == "EXECUTABLE" )
{
itype = cmTarget::EXECUTABLE;
}
else if ( stype == "PROGRAM" )
{
itype = cmTarget::INSTALL_PROGRAMS;
}
else if ( stype == "STATIC_LIBRARY" )
{
itype = cmTarget::STATIC_LIBRARY;
}
else if ( stype == "SHARED_LIBRARY" )
{
itype = cmTarget::SHARED_LIBRARY;
}
else if ( stype == "MODULE" )
{
itype = cmTarget::MODULE_LIBRARY;
}
if ( !cmSystemTools::FileExists(destination.c_str()) )
{
if ( !cmSystemTools::MakeDirectory(destination.c_str()) )
{
std::string errstring = "cannot create directory: " + destination +
". Maybe need administrative privileges.";
this->SetError(errstring.c_str());
return false;
}
}
if ( !cmSystemTools::FileIsDirectory(destination.c_str()) )
{
std::string errstring = "found file: " + destination +
" where expecting directory with the same name.";
this->SetError(errstring.c_str());
return false;
}
const char* manifest_files =
m_Makefile->GetDefinition("CMAKE_INSTALL_MANIFEST_FILES");
std::string smanifest_files;
if ( manifest_files )
{
smanifest_files = manifest_files;
}
for ( i = 0; i < files.size(); i ++ )
{
std::string destfilewe
= destination + "/"
+ cmSystemTools::GetFilenameWithoutExtension(files[i]);
std::string ctarget = files[i].c_str();
2004-02-03 18:53:41 +03:00
std::string fname = cmSystemTools::GetFilenameName(ctarget);
std::string ext = cmSystemTools::GetFilenameExtension(ctarget);
2004-02-13 05:44:24 +03:00
std::string fnamewe
= cmSystemTools::GetFilenameWithoutExtension(ctarget);
std::string destfile = destfilewe;
if ( ext.size() )
{
2004-06-30 16:59:52 +04:00
destfile += ext;
}
switch( itype )
{
case cmTarget::MODULE_LIBRARY:
case cmTarget::STATIC_LIBRARY:
case cmTarget::SHARED_LIBRARY:
2004-06-29 00:39:51 +04:00
if ( debug )
{
fname = fnamewe + debug_postfix + ext;
destfile = destfilewe + debug_postfix + ext;
2004-06-29 00:39:51 +04:00
}
2004-02-03 18:53:41 +03:00
{
// Handle shared library versioning
const char* lib_version = 0;
const char* lib_soversion = 0;
if ( properties.find("VERSION") != properties.end() )
{
lib_version = properties["VERSION"];
}
if ( properties.find("SOVERSION") != properties.end() )
{
lib_soversion = properties["SOVERSION"];
}
if ( !lib_version && lib_soversion )
{
lib_version = lib_soversion;
}
if ( !lib_soversion && lib_version )
{
lib_soversion = lib_version;
}
if ( lib_version && lib_soversion )
{
std::string libname = destfile;
std::string soname = destfile;
std::string soname_nopath = fname;
soname += ".";
soname += lib_soversion;
soname_nopath += ".";
soname_nopath += lib_soversion;
fname += ".";
fname += lib_version;
destfile += ".";
destfile += lib_version;
cmSystemTools::RemoveFile(soname.c_str());
cmSystemTools::RemoveFile(libname.c_str());
if (!cmSystemTools::CreateSymlink(soname_nopath.c_str(), libname.c_str()) )
{
std::string errstring = "error when creating symlink from: " + libname + " to " + soname_nopath;
this->SetError(errstring.c_str());
return false;
}
smanifest_files += ";";
smanifest_files += libname.substr(destDirLength);;
if ( destfile != soname )
{
if ( !cmSystemTools::CreateSymlink(fname.c_str(), soname.c_str()) )
{
std::string errstring = "error when creating symlink from: " + soname + " to " + fname;
this->SetError(errstring.c_str());
return false;
}
smanifest_files += ";";
smanifest_files += soname.substr(destDirLength);
}
}
cmOStringStream str;
2004-06-29 00:39:51 +04:00
str << cmSystemTools::GetFilenamePath(ctarget) << "/";
if ( extra_dir.size() > 0 )
{
str << extra_dir << "/";
}
str << fname;
ctarget = str.str();
2004-02-03 18:53:41 +03:00
}
2004-06-29 00:39:51 +04:00
break;
case cmTarget::EXECUTABLE:
if ( extra_dir.size() > 0 )
{
cmOStringStream str;
2004-02-13 05:44:24 +03:00
str << cmSystemTools::GetFilenamePath(ctarget)
<< "/" << extra_dir << "/"
2004-02-03 18:53:41 +03:00
<< fname;
ctarget = str.str();
}
break;
}
if ( !cmSystemTools::SameFile(ctarget.c_str(), destfile.c_str()) )
{
if ( cmSystemTools::FileExists(ctarget.c_str()) )
{
cmSystemTools::RemoveFile(destfile.c_str());
if ( !cmSystemTools::CopyFileAlways(ctarget.c_str(),
destination.c_str()) )
{
std::string errstring = "cannot copy file: " + ctarget +
" to directory : " + destination + ".";
this->SetError(errstring.c_str());
return false;
}
switch( itype )
{
2005-02-18 21:32:51 +03:00
case cmTarget::STATIC_LIBRARY:
#if defined(__APPLE_CC__)
{
std::string ranlib = "ranlib ";
ranlib += destfile;
if(!cmSystemTools::RunSingleCommand(ranlib.c_str()))
{
std::string err = "ranlib failed: ";
err += ranlib;
this->SetError(err.c_str());
}
}
#endif
break;
case cmTarget::MODULE_LIBRARY:
case cmTarget::SHARED_LIBRARY:
case cmTarget::EXECUTABLE:
case cmTarget::INSTALL_PROGRAMS:
if ( !cmSystemTools::SetPermissions(destfile.c_str(),
#if defined( _MSC_VER ) || defined( __MINGW32__ )
2005-02-18 21:32:51 +03:00
S_IREAD | S_IWRITE | S_IEXEC
#elif defined( __BORLANDC__ )
2005-02-18 21:32:51 +03:00
S_IRUSR | S_IWUSR | S_IXUSR
2004-01-27 00:24:35 +03:00
#else
2005-02-18 21:32:51 +03:00
S_IRUSR | S_IWUSR | S_IXUSR |
S_IRGRP | S_IXGRP |
S_IROTH | S_IXOTH
2004-01-27 00:24:35 +03:00
#endif
2005-02-18 21:32:51 +03:00
) )
{
cmOStringStream err;
err << "Problem setting permissions on file: "
<< destfile.c_str();
perror(err.str().c_str());
}
}
smanifest_files += ";";
smanifest_files += destfile.substr(destDirLength);
}
else
{
if ( !optional )
{
std::string errstring = "cannot find file: " +
ctarget + " to install.";
this->SetError(errstring.c_str());
return false;
}
}
}
}
m_Makefile->AddDefinition("CMAKE_INSTALL_MANIFEST_FILES",
smanifest_files.c_str());
return true;
}