hdf5.git - Mirror from: https://github.com/HDFGroup/hdf5.git

diff options

Diffstat (limited to 'src/H5HG.c')

-rw-r--r--

147

1 files changed, 23 insertions, 124 deletions

/*============================================================================ CMake - Cross Platform Makefile Generator Copyright 2000-2009 Kitware, Inc., Insight Software Consortium Distributed under the OSI-approved BSD License (the "License"); see accompanying file Copyright.txt for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the License for more information. ============================================================================*/ #include "cmFileCommand.h" #include "cmake.h" #include "cmHexFileConverter.h" #include "cmFileTimeComparison.h" #if defined(CMAKE_BUILD_WITH_CMAKE) #include "cm_curl.h" #endif #undef GetCurrentDirectory #include <sys/types.h> #include <sys/stat.h> #include <cmsys/Directory.hxx> #include <cmsys/Glob.hxx> #include <cmsys/RegularExpression.hxx> // Table of permissions flags. #if defined(_WIN32) && !defined(__CYGWIN__) static mode_t mode_owner_read = S_IREAD; static mode_t mode_owner_write = S_IWRITE; static mode_t mode_owner_execute = S_IEXEC; static mode_t mode_group_read = 0; static mode_t mode_group_write = 0; static mode_t mode_group_execute = 0; static mode_t mode_world_read = 0; static mode_t mode_world_write = 0; static mode_t mode_world_execute = 0; static mode_t mode_setuid = 0; static mode_t mode_setgid = 0; #else static mode_t mode_owner_read = S_IRUSR; static mode_t mode_owner_write = S_IWUSR; static mode_t mode_owner_execute = S_IXUSR; static mode_t mode_group_read = S_IRGRP; static mode_t mode_group_write = S_IWGRP; static mode_t mode_group_execute = S_IXGRP; static mode_t mode_world_read = S_IROTH; static mode_t mode_world_write = S_IWOTH; static mode_t mode_world_execute = S_IXOTH; static mode_t mode_setuid = S_ISUID; static mode_t mode_setgid = S_ISGID; #endif // cmLibraryCommand bool cmFileCommand ::InitialPass(std::vector<std::string> const& args, cmExecutionStatus &) { 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 == "DOWNLOAD" ) { return this->HandleDownloadCommand(args); } else if ( subCommand == "UPLOAD" ) { return this->HandleUploadCommand(args); } else if ( subCommand == "READ" ) { return this->HandleReadCommand(args); } else if ( subCommand == "STRINGS" ) { return this->HandleStringsCommand(args); } else if ( subCommand == "GLOB" ) { return this->HandleGlobCommand(args, false); } else if ( subCommand == "GLOB_RECURSE" ) { return this->HandleGlobCommand(args, true); } else if ( subCommand == "MAKE_DIRECTORY" ) { return this->HandleMakeDirectoryCommand(args); } else if ( subCommand == "RENAME" ) { return this->HandleRename(args); } else if ( subCommand == "REMOVE" ) { return this->HandleRemove(args, false); } else if ( subCommand == "REMOVE_RECURSE" ) { return this->HandleRemove(args, true); } else if ( subCommand == "COPY" ) { return this->HandleCopyCommand(args); } else if ( subCommand == "INSTALL" ) { return this->HandleInstallCommand(args); } else if ( subCommand == "DIFFERENT" ) { return this->HandleDifferentCommand(args); } else if ( subCommand == "RPATH_CHANGE" || subCommand == "CHRPATH" ) { return this->HandleRPathChangeCommand(args); } else if ( subCommand == "RPATH_CHECK" ) { return this->HandleRPathCheckCommand(args); } else if ( subCommand == "RPATH_REMOVE" ) { return this->HandleRPathRemoveCommand(args); } else if ( subCommand == "RELATIVE_PATH" ) { return this->HandleRelativePathCommand(args); } else if ( subCommand == "TO_CMAKE_PATH" ) { return this->HandleCMakePathCommand(args, false); } else if ( subCommand == "TO_NATIVE_PATH" ) { return this->HandleCMakePathCommand(args, true); } 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; if ( !cmsys::SystemTools::FileIsFullPath(i->c_str()) ) { fileName = this->Makefile->GetCurrentDirectory(); fileName += "/" + *i; } i++; for(;i != args.end(); ++i) { message += *i; } if ( !this->Makefile->CanIWriteThisFile(fileName.c_str()) ) { std::string e = "attempted to write a file: " + fileName + " into a source directory."; this->SetError(e.c_str()); cmSystemTools::SetFatalErrorOccured(); return false; } std::string dir = cmSystemTools::GetFilenamePath(fileName); cmSystemTools::MakeDirectory(dir.c_str()); mode_t mode = 0; // Set permissions to writable if ( cmSystemTools::GetPermissions(fileName.c_str(), mode) ) { cmSystemTools::SetPermissions(fileName.c_str(), #if defined( _MSC_VER ) || defined( __MINGW32__ ) mode | S_IWRITE #elif defined( __BORLANDC__ ) mode | S_IWUSR #else mode | S_IWUSR | S_IWGRP #endif ); } // If GetPermissions fails, pretend like it is ok. File open will fail if // the file is not writable 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 writing."; this->SetError(error.c_str()); return false; } file << message; file.close(); if(mode) { cmSystemTools::SetPermissions(fileName.c_str(), mode); } return true; } //---------------------------------------------------------------------------- bool cmFileCommand::HandleReadCommand(std::vector<std::string> const& args) { if ( args.size() < 3 ) { this->SetError("READ must be called with at least two additional " "arguments"); return false; } cmCommandArgumentsHelper argHelper; cmCommandArgumentGroup group; cmCAString readArg (&argHelper, "READ"); cmCAString fileNameArg (&argHelper, 0); cmCAString resultArg (&argHelper, 0); cmCAString offsetArg (&argHelper, "OFFSET", &group); cmCAString limitArg (&argHelper, "LIMIT", &group); cmCAEnabler hexOutputArg (&argHelper, "HEX", &group); readArg.Follows(0); fileNameArg.Follows(&readArg); resultArg.Follows(&fileNameArg); group.Follows(&resultArg); argHelper.Parse(&args, 0); std::string fileName = fileNameArg.GetString(); if ( !cmsys::SystemTools::FileIsFullPath(fileName.c_str()) ) { fileName = this->Makefile->GetCurrentDirectory(); fileName += "/" + fileNameArg.GetString(); } std::string variable = resultArg.GetString(); // Open the specified file. #if defined(_WIN32) || defined(__CYGWIN__) std::ifstream file(fileName.c_str(), std::ios::in | (hexOutputArg.IsEnabled() ? std::ios::binary : std::ios::in)); #else std::ifstream file(fileName.c_str(), std::ios::in); #endif 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; } // is there a limit? long sizeLimit = -1; if (limitArg.GetString().size() > 0) { sizeLimit = atoi(limitArg.GetCString()); } // is there an offset? long offset = 0; if (offsetArg.GetString().size() > 0) { offset = atoi(offsetArg.GetCString()); } file.seekg(offset); std::string output; if (hexOutputArg.IsEnabled()) { // Convert part of the file into hex code char c; while((sizeLimit != 0) && (file.get(c))) { char hex[4]; sprintf(hex, "%.2x", c&0xff); output += hex; if (sizeLimit > 0) { sizeLimit--; } } } else { std::string line; bool has_newline = false; while (sizeLimit != 0 && cmSystemTools::GetLineFromStream(file, line, &has_newline, sizeLimit) ) { if (sizeLimit > 0) { sizeLimit = sizeLimit - static_cast<long>(line.size()); if (has_newline) { sizeLimit--; } if (sizeLimit < 0) { sizeLimit = 0; } } output += line; if ( has_newline ) { output += "\n"; } } } this->Makefile->AddDefinition(variable.c_str(), output.c_str()); return true; } //---------------------------------------------------------------------------- bool cmFileCommand::HandleStringsCommand(std::vector<std::string> const& args) { if(args.size() < 3) { this->SetError("STRINGS requires a file name and output variable"); return false; } // Get the file to read. std::string fileName = args[1]; if(!cmsys::SystemTools::FileIsFullPath(fileName.c_str())) { fileName = this->Makefile->GetCurrentDirectory(); fileName += "/" + args[1]; } // Get the variable in which to store the results. std::string outVar = args[2]; // Parse the options. enum { arg_none, arg_limit_input, arg_limit_output, arg_limit_count, arg_length_minimum, arg_length_maximum, arg__maximum, arg_regex }; unsigned int minlen = 0; unsigned int maxlen = 0; int limit_input = -1; int limit_output = -1; unsigned int limit_count = 0; cmsys::RegularExpression regex; bool have_regex = false; bool newline_consume = false; bool hex_conversion_enabled = true; int arg_mode = arg_none; for(unsigned int i=3; i < args.size(); ++i) { if(args[i] == "LIMIT_INPUT") { arg_mode = arg_limit_input; } else if(args[i] == "LIMIT_OUTPUT") { arg_mode = arg_limit_output; } else if(args[i] == "LIMIT_COUNT") { arg_mode = arg_limit_count; } else if(args[i] == "LENGTH_MINIMUM") { arg_mode = arg_length_minimum; } else if(args[i] == "LENGTH_MAXIMUM") { arg_mode = arg_length_maximum; } else if(args[i] == "REGEX") { arg_mode = arg_regex; } else if(args[i] == "NEWLINE_CONSUME") { newline_consume = true; arg_mode = arg_none; } else if(args[i] == "NO_HEX_CONVERSION") { hex_conversion_enabled = false; arg_mode = arg_none; } else if(arg_mode == arg_limit_input) { if(sscanf(args[i].c_str(), "%d", &limit_input) != 1 || limit_input < 0) { cmOStringStream e; e << "STRINGS option LIMIT_INPUT value \"" << args[i] << "\" is not an unsigned integer."; this->SetError(e.str().c_str()); return false; } arg_mode = arg_none; } else if(arg_mode == arg_limit_output) { if(sscanf(args[i].c_str(), "%d", &limit_output) != 1 || limit_output < 0) { cmOStringStream e; e << "STRINGS option LIMIT_OUTPUT value \"" << args[i] << "\" is not an unsigned integer."; this->SetError(e.str().c_str()); return false; } arg_mode = arg_none; } else if(arg_mode == arg_limit_count) { int count; if(sscanf(args[i].c_str(), "%d", &count) != 1 || count < 0) { cmOStringStream e; e << "STRINGS option LIMIT_COUNT value \"" << args[i] << "\" is not an unsigned integer."; this->SetError(e.str().c_str()); return false; } limit_count = count; arg_mode = arg_none; } else if(arg_mode == arg_length_minimum) { int len; if(sscanf(args[i].c_str(), "%d", &len) != 1 || len < 0) { cmOStringStream e; e << "STRINGS option LENGTH_MINIMUM value \"" << args[i] << "\" is not an unsigned integer."; this->SetError(e.str().c_str()); return false; } minlen = len; arg_mode = arg_none; } else if(arg_mode == arg_length_maximum) { int len; if(sscanf(args[i].c_str(), "%d", &len) != 1 || len < 0) { cmOStringStream e; e << "STRINGS option LENGTH_MAXIMUM value \"" << args[i] << "\" is not an unsigned integer."; this->SetError(e.str().c_str()); return false; } maxlen = len; arg_mode = arg_none; } else if(arg_mode == arg_regex) { if(!regex.compile(args[i].c_str())) { cmOStringStream e; e << "STRINGS option REGEX value \"" << args[i] << "\" could not be compiled."; this->SetError(e.str().c_str()); return false; } have_regex = true; arg_mode = arg_none; } else { cmOStringStream e; e << "STRINGS given unknown argument \"" << args[i] << "\""; this->SetError(e.str().c_str()); return false; } } if (hex_conversion_enabled) { // TODO: should work without temp file, but just on a memory buffer std::string binaryFileName = this->Makefile->GetCurrentOutputDirectory(); binaryFileName += cmake::GetCMakeFilesDirectory(); binaryFileName += "/FileCommandStringsBinaryFile"; if(cmHexFileConverter::TryConvert(fileName.c_str(),binaryFileName.c_str())) { fileName = binaryFileName; } } // Open the specified file. #if defined(_WIN32) || defined(__CYGWIN__) std::ifstream fin(fileName.c_str(), std::ios::in | std::ios::binary); #else std::ifstream fin(fileName.c_str(), std::ios::in); #endif if(!fin) { cmOStringStream e; e << "STRINGS file \"" << fileName << "\" cannot be read."; this->SetError(e.str().c_str()); return false; } // Parse strings out of the file. int output_size = 0; std::vector<std::string> strings; std::string s; int c; while((!limit_count || strings.size() < limit_count) && (limit_input < 0 || static_cast<int>(fin.tellg()) < limit_input) && (c = fin.get(), fin)) { if(c == '\n' && !newline_consume) { // The current line has been terminated. Check if the current // string matches the requirements. The length may now be as // low as zero since blank lines are allowed. if(s.length() >= minlen && (!have_regex || regex.find(s.c_str()))) { output_size += static_cast<int>(s.size()) + 1; if(limit_output >= 0 && output_size >= limit_output) { s = ""; break; } strings.push_back(s); } // Reset the string to empty. s = ""; } else if(c == '\r') { // Ignore CR character to make output always have UNIX newlines. } else if((c >= 0x20 && c < 0x7F) || c == '\t' || (c == '\n' && newline_consume)) { // This is an ASCII character that may be part of a string. // Cast added to avoid compiler warning. Cast is ok because // c is guaranteed to fit in char by the above if... s += static_cast<char>(c); } else { // TODO: Support ENCODING option. See issue #10519. // A non-string character has been found. Check if the current // string matches the requirements. We require that the length // be at least one no matter what the user specified. if(s.length() >= minlen && s.length() >= 1 && (!have_regex || regex.find(s.c_str()))) { output_size += static_cast<int>(s.size()) + 1; if(limit_output >= 0 && output_size >= limit_output) { s = ""; break; } strings.push_back(s); } // Reset the string to empty. s = ""; } // Terminate a string if the maximum length is reached. if(maxlen > 0 && s.size() == maxlen) { if(s.length() >= minlen && (!have_regex || regex.find(s.c_str()))) { output_size += static_cast<int>(s.size()) + 1; if(limit_output >= 0 && output_size >= limit_output) { s = ""; break; } strings.push_back(s); } s = ""; } } // If there is a non-empty current string we have hit the end of the // input file or the input size limit. Check if the current string // matches the requirements. if((!limit_count || strings.size() < limit_count) && !s.empty() && s.length() >= minlen && (!have_regex || regex.find(s.c_str()))) { output_size += static_cast<int>(s.size()) + 1; if(limit_output < 0 || output_size < limit_output) { strings.push_back(s); } } // Encode the result in a CMake list. const char* sep = ""; std::string output; for(std::vector<std::string>::const_iterator si = strings.begin(); si != strings.end(); ++si) { // Separate the strings in the output to make it a list. output += sep; sep = ";"; // Store the string in the output, but escape semicolons to // make sure it is a list. std::string const& sr = *si; for(unsigned int i=0; i < sr.size(); ++i) { if(sr[i] == ';') { output += '\\'; } output += sr[i]; } } // Save the output in a makefile variable. this->Makefile->AddDefinition(outVar.c_str(), output.c_str()); return true; } //---------------------------------------------------------------------------- bool cmFileCommand::HandleGlobCommand(std::vector<std::string> const& args, bool recurse) { if ( args.size() < 2 ) { this->SetError("GLOB requires at least a variable name"); return false; } std::vector<std::string>::const_iterator i = args.begin(); i++; // Get rid of subcommand std::string variable = *i; i++; cmsys::Glob g; g.SetRecurse(recurse); bool explicitFollowSymlinks = false; cmPolicies::PolicyStatus status = this->Makefile->GetPolicyStatus(cmPolicies::CMP0009); if(recurse) { switch(status) { case cmPolicies::NEW: g.RecurseThroughSymlinksOff(); break; case cmPolicies::OLD: case cmPolicies::WARN: case cmPolicies::REQUIRED_IF_USED: case cmPolicies::REQUIRED_ALWAYS: g.RecurseThroughSymlinksOn(); break; } } std::string output = ""; bool first = true; for ( ; i != args.end(); ++i ) { if ( recurse && (*i == "FOLLOW_SYMLINKS") ) { explicitFollowSymlinks = true; g.RecurseThroughSymlinksOn(); ++i; if ( i == args.end() ) { this->SetError( "GLOB_RECURSE requires a glob expression after FOLLOW_SYMLINKS"); return false; } } if ( *i == "RELATIVE" ) { ++i; // skip RELATIVE if ( i == args.end() ) { this->SetError("GLOB requires a directory after the RELATIVE tag"); return false; } g.SetRelative(i->c_str()); ++i; if(i == args.end()) { this->SetError("GLOB requires a glob expression after the directory"); return false; } } if ( !cmsys::SystemTools::FileIsFullPath(i->c_str()) ) { std::string expr = this->Makefile->GetCurrentDirectory(); // Handle script mode if ( expr.size() > 0 ) { expr += "/" + *i; g.FindFiles(expr); } else { g.FindFiles(*i); } } 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; } } if(recurse && !explicitFollowSymlinks) { switch (status) { case cmPolicies::NEW: // Correct behavior, yay! break; case cmPolicies::OLD: // Probably not really the expected behavior, but the author explicitly // asked for the old behavior... no warning. case cmPolicies::WARN: // Possibly unexpected old behavior *and* we actually traversed // symlinks without being explicitly asked to: warn the author. if(g.GetFollowedSymlinkCount() != 0) { this->Makefile->IssueMessage(cmake::AUTHOR_WARNING, this->Makefile->GetPolicies()-> GetPolicyWarning(cmPolicies::CMP0009)); } break; case cmPolicies::REQUIRED_IF_USED: case cmPolicies::REQUIRED_ALWAYS: this->SetError("policy CMP0009 error"); this->Makefile->IssueMessage(cmake::FATAL_ERROR, this->Makefile->GetPolicies()-> GetRequiredPolicyError(cmPolicies::CMP0009)); return false; } } this->Makefile->AddDefinition(variable.c_str(), output.c_str()); return true; } //---------------------------------------------------------------------------- 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 = this->Makefile->GetCurrentDirectory(); expr += "/" + *i; cdir = &expr; } if ( !this->Makefile->CanIWriteThisFile(cdir->c_str()) ) { std::string e = "attempted to create a directory: " + *cdir + " into a source directory."; this->SetError(e.c_str()); cmSystemTools::SetFatalErrorOccured(); return false; } if ( !cmSystemTools::MakeDirectory(cdir->c_str()) ) { std::string error = "problem creating directory: " + *cdir; this->SetError(error.c_str()); return false; } } return true; } //---------------------------------------------------------------------------- bool cmFileCommand::HandleDifferentCommand(std::vector<std::string> const& args) { /* FILE(DIFFERENT <variable> FILES <lhs> <rhs>) */ // Evaluate arguments. const char* file_lhs = 0; const char* file_rhs = 0; const char* var = 0; enum Doing { DoingNone, DoingVar, DoingFileLHS, DoingFileRHS }; Doing doing = DoingVar; for(unsigned int i=1; i < args.size(); ++i) { if(args[i] == "FILES") { doing = DoingFileLHS; } else if(doing == DoingVar) { var = args[i].c_str(); doing = DoingNone; } else if(doing == DoingFileLHS) { file_lhs = args[i].c_str(); doing = DoingFileRHS; } else if(doing == DoingFileRHS) { file_rhs = args[i].c_str(); doing = DoingNone; } else { cmOStringStream e; e << "DIFFERENT given unknown argument " << args[i]; this->SetError(e.str().c_str()); return false; } } if(!var) { this->SetError("DIFFERENT not given result variable name."); return false; } if(!file_lhs || !file_rhs) { this->SetError("DIFFERENT not given FILES option with two file names."); return false; } // Compare the files. const char* result = cmSystemTools::FilesDiffer(file_lhs, file_rhs)? "1" : "0"; this->Makefile->AddDefinition(var, result); return true; } //---------------------------------------------------------------------------- // File installation helper class. struct cmFileCopier { cmFileCopier(cmFileCommand* command, const char* name = "COPY"): FileCommand(command), Makefile(command->GetMakefile()), Name(name), Always(false), MatchlessFiles(true), FilePermissions(0), DirPermissions(0), CurrentMatchRule(0), UseGivenPermissionsFile(false), UseGivenPermissionsDir(false), UseSourcePermissions(true), Doing(DoingNone) { } virtual ~cmFileCopier() {} bool Run(std::vector<std::string> const& args); protected: cmFileCommand* FileCommand; cmMakefile* Makefile; const char* Name; bool Always; cmFileTimeComparison FileTimes; // Whether to install a file not matching any expression. bool MatchlessFiles; // Permissions for files and directories installed by this object. mode_t FilePermissions; mode_t DirPermissions; // Properties set by pattern and regex match rules. struct MatchProperties { bool Exclude; mode_t Permissions; MatchProperties(): Exclude(false), Permissions(0) {} }; struct MatchRule; friend struct MatchRule; struct MatchRule { cmsys::RegularExpression Regex; MatchProperties Properties; std::string RegexString; MatchRule(std::string const& regex): Regex(regex.c_str()), RegexString(regex) {} }; std::vector<MatchRule> MatchRules; // Get the properties from rules matching this input file. MatchProperties CollectMatchProperties(const char* file) { // Match rules are case-insensitive on some platforms. #if defined(_WIN32) || defined(__APPLE__) || defined(__CYGWIN__) std::string lower = cmSystemTools::LowerCase(file); file = lower.c_str(); #endif // Collect properties from all matching rules. bool matched = false; MatchProperties result; for(std::vector<MatchRule>::iterator mr = this->MatchRules.begin(); mr != this->MatchRules.end(); ++mr) { if(mr->Regex.find(file)) { matched = true; result.Exclude |= mr->Properties.Exclude; result.Permissions |= mr->Properties.Permissions; } } if(!matched && !this->MatchlessFiles) { result.Exclude = !cmSystemTools::FileIsDirectory(file); } return result; } bool SetPermissions(const char* toFile, mode_t permissions) { if(permissions && !cmSystemTools::SetPermissions(toFile, permissions)) { cmOStringStream e; e << this->Name << " cannot set permissions on \"" << toFile << "\""; this->FileCommand->SetError(e.str().c_str()); return false; } return true; } // Translate an argument to a permissions bit. bool CheckPermissions(std::string const& arg, mode_t& permissions) { if(arg == "OWNER_READ") { permissions |= mode_owner_read; } else if(arg == "OWNER_WRITE") { permissions |= mode_owner_write; } else if(arg == "OWNER_EXECUTE") { permissions |= mode_owner_execute; } else if(arg == "GROUP_READ") { permissions |= mode_group_read; } else if(arg == "GROUP_WRITE") { permissions |= mode_group_write; } else if(arg == "GROUP_EXECUTE") { permissions |= mode_group_execute; } else if(arg == "WORLD_READ") { permissions |= mode_world_read; } else if(arg == "WORLD_WRITE") { permissions |= mode_world_write; } else if(arg == "WORLD_EXECUTE") { permissions |= mode_world_execute; } else if(arg == "SETUID") { permissions |= mode_setuid; } else if(arg == "SETGID") { permissions |= mode_setgid; } else { cmOStringStream e; e << this->Name << " given invalid permission \"" << arg << "\"."; this->FileCommand->SetError(e.str().c_str()); return false; } return true; } bool InstallSymlink(const char* fromFile, const char* toFile); bool InstallFile(const char* fromFile, const char* toFile, MatchProperties const& match_properties); bool InstallDirectory(const char* source, const char* destination, MatchProperties const& match_properties); virtual bool Install(const char* fromFile, const char* toFile); virtual std::string const& ToName(std::string const& fromName) { return fromName; } enum Type { TypeFile, TypeDir, TypeLink }; virtual void ReportCopy(const char*, Type, bool) {} virtual bool ReportMissing(const char* fromFile) { // The input file does not exist and installation is not optional. cmOStringStream e; e << this->Name << " cannot find \"" << fromFile << "\"."; this->FileCommand->SetError(e.str().c_str()); return false; } MatchRule* CurrentMatchRule; bool UseGivenPermissionsFile; bool UseGivenPermissionsDir; bool UseSourcePermissions; std::string Destination; std::vector<std::string> Files; int Doing; virtual bool Parse(std::vector<std::string> const& args); enum { DoingNone, DoingError, DoingDestination, DoingFiles, DoingPattern, DoingRegex, DoingPermissionsFile, DoingPermissionsDir, DoingPermissionsMatch, DoingLast1 }; virtual bool CheckKeyword(std::string const& arg); virtual bool CheckValue(std::string const& arg); void NotBeforeMatch(std::string const& arg) { cmOStringStream e; e << "option " << arg << " may not appear before PATTERN or REGEX."; this->FileCommand->SetError(e.str().c_str()); this->Doing = DoingError; } void NotAfterMatch(std::string const& arg) { cmOStringStream e; e << "option " << arg << " may not appear after PATTERN or REGEX."; this->FileCommand->SetError(e.str().c_str()); this->Doing = DoingError; } virtual void DefaultFilePermissions() { // Use read/write permissions. this->FilePermissions = 0; this->FilePermissions |= mode_owner_read; this->FilePermissions |= mode_owner_write; this->FilePermissions |= mode_group_read; this->FilePermissions |= mode_world_read; } virtual void DefaultDirectoryPermissions() { // Use read/write/executable permissions. this->DirPermissions = 0; this->DirPermissions |= mode_owner_read; this->DirPermissions |= mode_owner_write; this->DirPermissions |= mode_owner_execute; this->DirPermissions |= mode_group_read; this->DirPermissions |= mode_group_execute; this->DirPermissions |= mode_world_read; this->DirPermissions |= mode_world_execute; } }; //---------------------------------------------------------------------------- bool cmFileCopier::Parse(std::vector<std::string> const& args) { this->Doing = DoingFiles; for(unsigned int i=1; i < args.size(); ++i) { // Check this argument. if(!this->CheckKeyword(args[i]) && !this->CheckValue(args[i])) { cmOStringStream e; e << "called with unknown argument \"" << args[i] << "\"."; this->FileCommand->SetError(e.str().c_str()); return false; } // Quit if an argument is invalid. if(this->Doing == DoingError) { return false; } } // Require a destination. if(this->Destination.empty()) { cmOStringStream e; e << this->Name << " given no DESTINATION"; this->FileCommand->SetError(e.str().c_str()); return false; } // If file permissions were not specified set default permissions. if(!this->UseGivenPermissionsFile && !this->UseSourcePermissions) { this->DefaultFilePermissions(); } // If directory permissions were not specified set default permissions. if(!this->UseGivenPermissionsDir && !this->UseSourcePermissions) { this->DefaultDirectoryPermissions(); } return true; } //---------------------------------------------------------------------------- bool cmFileCopier::CheckKeyword(std::string const& arg) { if(arg == "DESTINATION") { if(this->CurrentMatchRule) { this->NotAfterMatch(arg); } else { this->Doing = DoingDestination; } } else if(arg == "PATTERN") { this->Doing = DoingPattern; } else if(arg == "REGEX") { this->Doing = DoingRegex; } else if(arg == "EXCLUDE") { // Add this property to the current match rule. if(this->CurrentMatchRule) { this->CurrentMatchRule->Properties.Exclude = true; this->Doing = DoingNone; } else { this->NotBeforeMatch(arg); } } else if(arg == "PERMISSIONS") { if(this->CurrentMatchRule) { this->Doing = DoingPermissionsMatch; } else { this->NotBeforeMatch(arg); } } else if(arg == "FILE_PERMISSIONS") { if(this->CurrentMatchRule) { this->NotAfterMatch(arg); } else { this->Doing = DoingPermissionsFile; this->UseGivenPermissionsFile = true; } } else if(arg == "DIRECTORY_PERMISSIONS") { if(this->CurrentMatchRule) { this->NotAfterMatch(arg); } else { this->Doing = DoingPermissionsDir; this->UseGivenPermissionsDir = true; } } else if(arg == "USE_SOURCE_PERMISSIONS") { if(this->CurrentMatchRule) { this->NotAfterMatch(arg); } else { this->Doing = DoingNone; this->UseSourcePermissions = true; } } else if(arg == "NO_SOURCE_PERMISSIONS") { if(this->CurrentMatchRule) { this->NotAfterMatch(arg); } else { this->Doing = DoingNone; this->UseSourcePermissions = false; } } else if(arg == "FILES_MATCHING") { if(this->CurrentMatchRule) { this->NotAfterMatch(arg); } else { this->Doing = DoingNone; this->MatchlessFiles = false; } } else { return false; } return true; } //---------------------------------------------------------------------------- bool cmFileCopier::CheckValue(std::string const& arg) { switch(this->Doing) { case DoingFiles: if(arg.empty() || cmSystemTools::FileIsFullPath(arg.c_str())) { this->Files.push_back(arg); } else { std::string file = this->Makefile->GetCurrentDirectory(); file += "/" + arg; this->Files.push_back(file); } break; case DoingDestination: if(arg.empty() || cmSystemTools::FileIsFullPath(arg.c_str())) { this->Destination = arg; } else { this->Destination = this->Makefile->GetCurrentOutputDirectory(); this->Destination += "/" + arg; } this->Doing = DoingNone; break; case DoingPattern: { // Convert the pattern to a regular expression. Require a // leading slash and trailing end-of-string in the matched // string to make sure the pattern matches only whole file // names. std::string regex = "/"; regex += cmsys::Glob::PatternToRegex(arg, false); regex += "$"; this->MatchRules.push_back(MatchRule(regex)); this->CurrentMatchRule = &*(this->MatchRules.end()-1); if(this->CurrentMatchRule->Regex.is_valid()) { this->Doing = DoingNone; } else { cmOStringStream e; e << "could not compile PATTERN \"" << arg << "\"."; this->FileCommand->SetError(e.str().c_str()); this->Doing = DoingError; } } break; case DoingRegex: this->MatchRules.push_back(MatchRule(arg)); this->CurrentMatchRule = &*(this->MatchRules.end()-1); if(this->CurrentMatchRule->Regex.is_valid()) { this->Doing = DoingNone; } else { cmOStringStream e; e << "could not compile REGEX \"" << arg << "\"."; this->FileCommand->SetError(e.str().c_str()); this->Doing = DoingError; } break; case DoingPermissionsFile: if(!this->CheckPermissions(arg, this->FilePermissions)) { this->Doing = DoingError; } break; case DoingPermissionsDir: if(!this->CheckPermissions(arg, this->DirPermissions)) { this->Doing = DoingError; } break; case DoingPermissionsMatch: if(!this->CheckPermissions( arg, this->CurrentMatchRule->Properties.Permissions)) { this->Doing = DoingError; } break; default: return false; } return true; } //---------------------------------------------------------------------------- bool cmFileCopier::Run(std::vector<std::string> const& args) { if(!this->Parse(args)) { return false; } std::vector<std::string> const& files = this->Files; for(std::vector<std::string>::size_type i = 0; i < files.size(); ++i) { // Split the input file into its directory and name components. std::vector<std::string> fromPathComponents; cmSystemTools::SplitPath(files[i].c_str(), fromPathComponents); std::string fromName = *(fromPathComponents.end()-1); std::string fromDir = cmSystemTools::JoinPath(fromPathComponents.begin(), fromPathComponents.end()-1); // Compute the full path to the destination file. std::string toFile = this->Destination; std::string const& toName = this->ToName(fromName); if(!toName.empty()) { toFile += "/"; toFile += toName; } // Construct the full path to the source file. The file name may // have been changed above. std::string fromFile = fromDir; if(!fromName.empty()) { fromFile += "/"; fromFile += fromName; } if(!this->Install(fromFile.c_str(), toFile.c_str())) { return false; } } return true; } //---------------------------------------------------------------------------- bool cmFileCopier::Install(const char* fromFile, const char* toFile) { if(!*fromFile) { cmOStringStream e; e << "INSTALL encountered an empty string input file name."; this->FileCommand->SetError(e.str().c_str()); return false; } // Collect any properties matching this file name. MatchProperties match_properties = this->CollectMatchProperties(fromFile); // Skip the file if it is excluded. if(match_properties.Exclude) { return true; } if(cmSystemTools::SameFile(fromFile, toFile)) { return true; } else if(cmSystemTools::FileIsSymlink(fromFile)) { return this->InstallSymlink(fromFile, toFile); } else if(cmSystemTools::FileIsDirectory(fromFile)) { return this->InstallDirectory(fromFile, toFile, match_properties); } else if(cmSystemTools::FileExists(fromFile)) { return this->InstallFile(fromFile, toFile, match_properties); } return this->ReportMissing(fromFile); } //---------------------------------------------------------------------------- bool cmFileCopier::InstallSymlink(const char* fromFile, const char* toFile) { // Read the original symlink. std::string symlinkTarget; if(!cmSystemTools::ReadSymlink(fromFile, symlinkTarget)) { cmOStringStream e; e << this->Name << " cannot read symlink \"" << fromFile << "\" to duplicate at \"" << toFile << "\"."; this->FileCommand->SetError(e.str().c_str()); return false; } // Compare the symlink value to that at the destination if not // always installing. bool copy = true; if(!this->Always) { std::string oldSymlinkTarget; if(cmSystemTools::ReadSymlink(toFile, oldSymlinkTarget)) { if(symlinkTarget == oldSymlinkTarget) { copy = false; } } } // Inform the user about this file installation. this->ReportCopy(toFile, TypeLink, copy); if(copy) { // Remove the destination file so we can always create the symlink. cmSystemTools::RemoveFile(toFile); // Create the symlink. if(!cmSystemTools::CreateSymlink(symlinkTarget.c_str(), toFile)) { cmOStringStream e; e << this->Name << " cannot duplicate symlink \"" << fromFile << "\" at \"" << toFile << "\"."; this->FileCommand->SetError(e.str().c_str()); return false; } } return true; } //---------------------------------------------------------------------------- bool cmFileCopier::InstallFile(const char* fromFile, const char* toFile, MatchProperties const& match_properties) { // Determine whether we will copy the file. bool copy = true; if(!this->Always) { // If both files exist with the same time do not copy. if(!this->FileTimes.FileTimesDiffer(fromFile, toFile)) { copy = false; } } // Inform the user about this file installation. this->ReportCopy(toFile, TypeFile, copy); // Copy the file. if(copy && !cmSystemTools::CopyAFile(fromFile, toFile, true)) { cmOStringStream e; e << this->Name << " cannot copy file \"" << fromFile << "\" to \"" << toFile << "\"."; this->FileCommand->SetError(e.str().c_str()); return false; } // Set the file modification time of the destination file. if(copy && !this->Always) { // Add write permission so we can set the file time. // Permissions are set unconditionally below anyway. mode_t perm = 0; if(cmSystemTools::GetPermissions(toFile, perm)) { cmSystemTools::SetPermissions(toFile, perm | mode_owner_write); } if (!cmSystemTools::CopyFileTime(fromFile, toFile)) { cmOStringStream e; e << this->Name << " cannot set modification time on \"" << toFile << "\""; this->FileCommand->SetError(e.str().c_str()); return false; } } // Set permissions of the destination file. mode_t permissions = (match_properties.Permissions? match_properties.Permissions : this->FilePermissions); if(!permissions) { // No permissions were explicitly provided but the user requested // that the source file permissions be used. cmSystemTools::GetPermissions(fromFile, permissions); } return this->SetPermissions(toFile, permissions); } //---------------------------------------------------------------------------- bool cmFileCopier::InstallDirectory(const char* source, const char* destination, MatchProperties const& match_properties) { // Inform the user about this directory installation. this->ReportCopy(destination, TypeDir, true); // Make sure the destination directory exists. if(!cmSystemTools::MakeDirectory(destination)) { cmOStringStream e; e << this->Name << " cannot make directory \"" << destination << "\": " << cmSystemTools::GetLastSystemError(); this->FileCommand->SetError(e.str().c_str()); return false; } // Compute the requested permissions for the destination directory. mode_t permissions = (match_properties.Permissions? match_properties.Permissions : this->DirPermissions); if(!permissions) { // No permissions were explicitly provided but the user requested // that the source directory permissions be used. cmSystemTools::GetPermissions(source, permissions); } // Compute the set of permissions required on this directory to // recursively install files and subdirectories safely. mode_t required_permissions = mode_owner_read | mode_owner_write | mode_owner_execute; // If the required permissions are specified it is safe to set the // final permissions now. Otherwise we must add the required // permissions temporarily during file installation. mode_t permissions_before = 0; mode_t permissions_after = 0; if((permissions & required_permissions) == required_permissions) { permissions_before = permissions; } else { permissions_before = permissions | required_permissions; permissions_after = permissions; } // Set the required permissions of the destination directory. if(!this->SetPermissions(destination, permissions_before)) { return false; } // Load the directory contents to traverse it recursively. cmsys::Directory dir; if(source && *source) { dir.Load(source); } unsigned long numFiles = static_cast<unsigned long>(dir.GetNumberOfFiles()); for(unsigned long fileNum = 0; fileNum < numFiles; ++fileNum) { if(!(strcmp(dir.GetFile(fileNum), ".") == 0 || strcmp(dir.GetFile(fileNum), "..") == 0)) { cmsys_stl::string fromPath = source; fromPath += "/"; fromPath += dir.GetFile(fileNum); std::string toPath = destination; toPath += "/"; toPath += dir.GetFile(fileNum); if(!this->Install(fromPath.c_str(), toPath.c_str())) { return false; } } } // Set the requested permissions of the destination directory. return this->SetPermissions(destination, permissions_after); } //---------------------------------------------------------------------------- bool cmFileCommand::HandleCopyCommand(std::vector<std::string> const& args) { cmFileCopier copier(this); return copier.Run(args); } //---------------------------------------------------------------------------- struct cmFileInstaller: public cmFileCopier {


context:
space:
mode: