diff options
Diffstat (limited to 'Source')
218 files changed, 9176 insertions, 7903 deletions
diff --git a/Source/CMakeLists.txt b/Source/CMakeLists.txt index ae5b03f..f23331b 100644 --- a/Source/CMakeLists.txt +++ b/Source/CMakeLists.txt @@ -299,8 +299,6 @@ set(SRCS cmLocalUnixMakefileGenerator3.cxx cmLocale.h ${MACH_SRCS} - cmMakeDepend.cxx - cmMakeDepend.h cmMakefile.cxx cmMakefile.h cmMakefileTargetGenerator.cxx @@ -548,6 +546,19 @@ foreach(v CURL_CA_BUNDLE CURL_CA_PATH) endif() endforeach() +foreach(check + STAT_HAS_ST_MTIM + STAT_HAS_ST_MTIMESPEC + ) + if(KWSYS_CXX_${check}_COMPILED) # abuse KWSys check cache entry + set(CMake_${check} 1) + else() + set(CMake_${check} 0) + endif() + set_property(SOURCE cmFileTimeComparison.cxx APPEND PROPERTY + COMPILE_DEFINITIONS CMake_${check}=${CMake_${check}}) +endforeach() + # create a library used by the command line and the GUI add_library(CMakeLib ${SRCS}) target_link_libraries(CMakeLib cmsys @@ -715,6 +726,9 @@ endif() # Build CPackLib add_library(CPackLib ${CPACK_SRCS}) target_link_libraries(CPackLib CMakeLib) +if(APPLE) + target_link_libraries(CPackLib "-framework Carbon") +endif() if(APPLE) add_executable(cmakexbuild cmakexbuild.cxx) diff --git a/Source/CMakeVersion.cmake b/Source/CMakeVersion.cmake index 0ce1696..c5a9682 100644 --- a/Source/CMakeVersion.cmake +++ b/Source/CMakeVersion.cmake @@ -1,5 +1,5 @@ # CMake version number components. set(CMake_VERSION_MAJOR 3) set(CMake_VERSION_MINOR 4) -set(CMake_VERSION_PATCH 0) -#set(CMake_VERSION_RC 0) +set(CMake_VERSION_PATCH 20151125) +#set(CMake_VERSION_RC 1) diff --git a/Source/CPack/IFW/cmCPackIFWGenerator.cxx b/Source/CPack/IFW/cmCPackIFWGenerator.cxx index 43d34ee..4eb23c1 100644 --- a/Source/CPack/IFW/cmCPackIFWGenerator.cxx +++ b/Source/CPack/IFW/cmCPackIFWGenerator.cxx @@ -24,7 +24,6 @@ #include <cmsys/RegularExpression.hxx> #include <cmGlobalGenerator.h> -#include <cmLocalGenerator.h> #include <cmSystemTools.h> #include <cmMakefile.h> #include <cmGeneratedFileStream.h> diff --git a/Source/CPack/WiX/cmCPackWIXGenerator.cxx b/Source/CPack/WiX/cmCPackWIXGenerator.cxx index 6f25e50..d5246db 100644 --- a/Source/CPack/WiX/cmCPackWIXGenerator.cxx +++ b/Source/CPack/WiX/cmCPackWIXGenerator.cxx @@ -482,6 +482,7 @@ bool cmCPackWIXGenerator::CreateWiXSourceFiles() featureDefinitions.BeginElement("Feature"); featureDefinitions.AddAttribute("Id", "ProductFeature"); featureDefinitions.AddAttribute("Display", "expand"); + featureDefinitions.AddAttribute("Absent", "disallow"); featureDefinitions.AddAttribute("ConfigurableDirectory", "INSTALL_ROOT"); std::string cpackPackageName; diff --git a/Source/CPack/WiX/cmWIXPatch.cxx b/Source/CPack/WiX/cmWIXPatch.cxx index 5a8dc63..471c3a4 100644 --- a/Source/CPack/WiX/cmWIXPatch.cxx +++ b/Source/CPack/WiX/cmWIXPatch.cxx @@ -33,13 +33,30 @@ void cmWIXPatch::ApplyFragment( if(i == Fragments.end()) return; const cmWIXPatchElement& fragment = i->second; + + this->ApplyElementChildren(fragment, writer); + + Fragments.erase(i); +} + +void cmWIXPatch::ApplyElementChildren( + const cmWIXPatchElement& element, cmWIXSourceWriter& writer) +{ for(cmWIXPatchElement::child_list_t::const_iterator - j = fragment.children.begin(); j != fragment.children.end(); ++j) + j = element.children.begin(); j != element.children.end(); ++j) + { + cmWIXPatchNode *node = *j; + + switch(node->type()) { - ApplyElement(**j, writer); + case cmWIXPatchNode::ELEMENT: + ApplyElement(dynamic_cast<const cmWIXPatchElement&>(*node), writer); + break; + case cmWIXPatchNode::TEXT: + writer.AddTextNode(dynamic_cast<const cmWIXPatchText&>(*node).text); + break; } - - Fragments.erase(i); + } } void cmWIXPatch::ApplyElement( @@ -53,16 +70,11 @@ void cmWIXPatch::ApplyElement( writer.AddAttribute(i->first, i->second); } - for(cmWIXPatchElement::child_list_t::const_iterator - i = element.children.begin(); i != element.children.end(); ++i) - { - ApplyElement(**i, writer); - } + this->ApplyElementChildren(element, writer); writer.EndElement(element.name); } - bool cmWIXPatch::CheckForUnappliedFragments() { std::string fragmentList; diff --git a/Source/CPack/WiX/cmWIXPatch.h b/Source/CPack/WiX/cmWIXPatch.h index 7b7b2f1..d53fcb4 100644 --- a/Source/CPack/WiX/cmWIXPatch.h +++ b/Source/CPack/WiX/cmWIXPatch.h @@ -33,6 +33,9 @@ public: bool CheckForUnappliedFragments(); private: + void ApplyElementChildren(const cmWIXPatchElement& element, + cmWIXSourceWriter& writer); + void ApplyElement(const cmWIXPatchElement& element, cmWIXSourceWriter& writer); diff --git a/Source/CPack/WiX/cmWIXPatchParser.cxx b/Source/CPack/WiX/cmWIXPatchParser.cxx index e066c28..14c5413 100644 --- a/Source/CPack/WiX/cmWIXPatchParser.cxx +++ b/Source/CPack/WiX/cmWIXPatchParser.cxx @@ -16,6 +16,21 @@ #include <cm_expat.h> +cmWIXPatchNode::Type cmWIXPatchText::type() +{ + return cmWIXPatchNode::TEXT; +} + +cmWIXPatchNode::Type cmWIXPatchElement::type() +{ + return cmWIXPatchNode::ELEMENT; +} + +cmWIXPatchNode::~cmWIXPatchNode() +{ + +} + cmWIXPatchElement::~cmWIXPatchElement() { for(child_list_t::iterator i = children.begin(); i != children.end(); ++i) @@ -63,20 +78,20 @@ void cmWIXPatchParser::StartElement(const std::string& name, const char **atts) { cmWIXPatchElement &parent = *ElementStack.back(); - parent.children.resize(parent.children.size() + 1); - cmWIXPatchElement*& currentElement = parent.children.back(); - currentElement = new cmWIXPatchElement; - currentElement->name = name; + cmWIXPatchElement *element = new cmWIXPatchElement; + parent.children.push_back(element); + + element->name = name; for(size_t i = 0; atts[i]; i += 2) { std::string key = atts[i]; std::string value = atts[i+1]; - currentElement->attributes[key] = value; + element->attributes[key] = value; } - ElementStack.push_back(currentElement); + ElementStack.push_back(element); } } @@ -117,11 +132,34 @@ void cmWIXPatchParser::EndElement(const std::string& name) } else { - ElementStack.pop_back(); + ElementStack.pop_back(); } } } +void cmWIXPatchParser::CharacterDataHandler(const char* data, int length) +{ + const char* whitespace = "\x20\x09\x0d\x0a"; + + if(State == INSIDE_FRAGMENT) + { + cmWIXPatchElement &parent = *ElementStack.back(); + + std::string text(data, length); + + std::string::size_type first = text.find_first_not_of(whitespace); + std::string::size_type last = text.find_last_not_of(whitespace); + + if(first != std::string::npos && last != std::string::npos) + { + cmWIXPatchText *text_node = new cmWIXPatchText; + text_node->text = text.substr(first, last - first + 1); + + parent.children.push_back(text_node); + } + } +} + void cmWIXPatchParser::ReportError(int line, int column, const char* msg) { cmCPackLogger(cmCPackLog::LOG_ERROR, diff --git a/Source/CPack/WiX/cmWIXPatchParser.h b/Source/CPack/WiX/cmWIXPatchParser.h index acfb4c0..acaeae3 100644 --- a/Source/CPack/WiX/cmWIXPatchParser.h +++ b/Source/CPack/WiX/cmWIXPatchParser.h @@ -20,11 +20,33 @@ #include <map> #include <list> -struct cmWIXPatchElement +struct cmWIXPatchNode { + enum Type + { + TEXT, + ELEMENT + }; + + virtual ~cmWIXPatchNode(); + + virtual Type type() = 0; +}; + +struct cmWIXPatchText : public cmWIXPatchNode +{ + virtual Type type(); + + std::string text; +}; + +struct cmWIXPatchElement : cmWIXPatchNode +{ + virtual Type type(); + ~cmWIXPatchElement(); - typedef std::list<cmWIXPatchElement*> child_list_t; + typedef std::list<cmWIXPatchNode*> child_list_t; typedef std::map<std::string, std::string> attributes_t; std::string name; @@ -48,6 +70,9 @@ private: void StartFragment(const char **attributes); virtual void EndElement(const std::string& name); + + virtual void CharacterDataHandler(const char* data, int length); + virtual void ReportError(int line, int column, const char* msg); void ReportValidationError(std::string const& message); diff --git a/Source/CPack/WiX/cmWIXSourceWriter.cxx b/Source/CPack/WiX/cmWIXSourceWriter.cxx index 8d38e9b..63acb27 100644 --- a/Source/CPack/WiX/cmWIXSourceWriter.cxx +++ b/Source/CPack/WiX/cmWIXSourceWriter.cxx @@ -102,6 +102,25 @@ void cmWIXSourceWriter::EndElement(std::string const& name) State = DEFAULT; } +void cmWIXSourceWriter::AddTextNode(std::string const& text) +{ + if(State == BEGIN) + { + File << ">"; + } + + if(Elements.empty()) + { + cmCPackLogger(cmCPackLog::LOG_ERROR, + "can not add text without open WiX element in '" << + SourceFilename << "'" << std::endl); + return; + } + + File << this->EscapeAttributeValue(text); + State = DEFAULT; +} + void cmWIXSourceWriter::AddProcessingInstruction( std::string const& target, std::string const& content) { diff --git a/Source/CPack/WiX/cmWIXSourceWriter.h b/Source/CPack/WiX/cmWIXSourceWriter.h index 3b9999c..9e303f0 100644 --- a/Source/CPack/WiX/cmWIXSourceWriter.h +++ b/Source/CPack/WiX/cmWIXSourceWriter.h @@ -34,6 +34,8 @@ public: void EndElement(std::string const& name); + void AddTextNode(std::string const& text); + void AddProcessingInstruction( std::string const& target, std::string const& content); diff --git a/Source/CPack/cmCPackArchiveGenerator.cxx b/Source/CPack/cmCPackArchiveGenerator.cxx index 70de757..db985db 100644 --- a/Source/CPack/cmCPackArchiveGenerator.cxx +++ b/Source/CPack/cmCPackArchiveGenerator.cxx @@ -14,7 +14,6 @@ #include "cmake.h" #include "cmGlobalGenerator.h" -#include "cmLocalGenerator.h" #include "cmSystemTools.h" #include "cmMakefile.h" #include "cmGeneratedFileStream.h" diff --git a/Source/CPack/cmCPackCygwinBinaryGenerator.cxx b/Source/CPack/cmCPackCygwinBinaryGenerator.cxx index 6605f16..1f905c0 100644 --- a/Source/CPack/cmCPackCygwinBinaryGenerator.cxx +++ b/Source/CPack/cmCPackCygwinBinaryGenerator.cxx @@ -14,7 +14,6 @@ #include "cmake.h" #include "cmGlobalGenerator.h" -#include "cmLocalGenerator.h" #include "cmSystemTools.h" #include "cmMakefile.h" #include "cmGeneratedFileStream.h" diff --git a/Source/CPack/cmCPackCygwinSourceGenerator.cxx b/Source/CPack/cmCPackCygwinSourceGenerator.cxx index f1e8539..f5cb53c 100644 --- a/Source/CPack/cmCPackCygwinSourceGenerator.cxx +++ b/Source/CPack/cmCPackCygwinSourceGenerator.cxx @@ -14,7 +14,6 @@ #include "cmake.h" #include "cmGlobalGenerator.h" -#include "cmLocalGenerator.h" #include "cmSystemTools.h" #include "cmMakefile.h" #include "cmGeneratedFileStream.h" diff --git a/Source/CPack/cmCPackDebGenerator.cxx b/Source/CPack/cmCPackDebGenerator.cxx index 04efb71..13c8d8f 100644 --- a/Source/CPack/cmCPackDebGenerator.cxx +++ b/Source/CPack/cmCPackDebGenerator.cxx @@ -339,6 +339,9 @@ int cmCPackDebGenerator::createDeb() this->GetOption("GEN_CPACK_DEBIAN_PACKAGE_PROVIDES"); const char* debian_pkg_replaces = this->GetOption("GEN_CPACK_DEBIAN_PACKAGE_REPLACES"); + const char* debian_pkg_source = + this->GetOption("GEN_CPACK_DEBIAN_PACKAGE_SOURCE"); + { // the scope is needed for cmGeneratedFileStream cmGeneratedFileStream out(ctlfilename.c_str()); @@ -347,6 +350,10 @@ int cmCPackDebGenerator::createDeb() out << "Section: " << debian_pkg_section << "\n"; out << "Priority: " << debian_pkg_priority << "\n"; out << "Architecture: " << debian_pkg_arch << "\n"; + if(debian_pkg_source && *debian_pkg_source) + { + out << "Source: " << debian_pkg_source << "\n"; + } if(debian_pkg_dep && *debian_pkg_dep) { out << "Depends: " << debian_pkg_dep << "\n"; diff --git a/Source/CPack/cmCPackDragNDropGenerator.cxx b/Source/CPack/cmCPackDragNDropGenerator.cxx index 4c400d9..b5df2d0 100644 --- a/Source/CPack/cmCPackDragNDropGenerator.cxx +++ b/Source/CPack/cmCPackDragNDropGenerator.cxx @@ -18,6 +18,24 @@ #include <cmsys/RegularExpression.hxx> #include <cmsys/FStream.hxx> +#include <iomanip> + +#include <CoreFoundation/CFBase.h> +#include <CoreFoundation/CFString.h> +#include <CoreFoundation/CFLocale.h> + +// The carbon framework is deprecated, but the Region codes it supplies are +// needed for the LPic data structure used for generating multi-lingual SLAs. +// There does not seem to be a replacement API for these region codes. +#if defined(__clang__) +# pragma clang diagnostic push +# pragma clang diagnostic ignored "-Wdeprecated-declarations" +#endif +#include <Carbon/Carbon.h> +#if defined(__clang__) +# pragma clang diagnostic pop +#endif + static const char* SLAHeader = "data 'LPic' (5000) {\n" " $\"0002 0011 0003 0001 0000 0000 0002 0000\"\n" @@ -103,6 +121,69 @@ int cmCPackDragNDropGenerator::InitializeInternal() } this->SetOptionIfNotSet("CPACK_COMMAND_REZ", rez_path.c_str()); + if(this->IsSet("CPACK_DMG_SLA_DIR")) + { + slaDirectory = this->GetOption("CPACK_DMG_SLA_DIR"); + if(!slaDirectory.empty() && this->IsSet("CPACK_RESOURCE_FILE_LICENSE")) + { + std::string license_file = + this->GetOption("CPACK_RESOURCE_FILE_LICENSE"); + if(!license_file.empty() && + (license_file.find("CPack.GenericLicense.txt") == std::string::npos)) + { + cmCPackLogger(cmCPackLog::LOG_WARNING, + "Both CPACK_DMG_SLA_DIR and CPACK_RESOURCE_FILE_LICENSE specified, " + "defaulting to CPACK_DMG_SLA_DIR" + << std::endl); + } + } + if(!this->IsSet("CPACK_DMG_SLA_LANGUAGES")) + { + cmCPackLogger(cmCPackLog::LOG_ERROR, + "CPACK_DMG_SLA_DIR set but no languages defined " + "(set CPACK_DMG_SLA_LANGUAGES)" + << std::endl); + return 0; + } + if(!cmSystemTools::FileExists(slaDirectory, false)) + { + cmCPackLogger(cmCPackLog::LOG_ERROR, + "CPACK_DMG_SLA_DIR does not exist" + << std::endl); + return 0; + } + + std::vector<std::string> languages; + cmSystemTools::ExpandListArgument( + this->GetOption("CPACK_DMG_SLA_LANGUAGES"), languages); + if(languages.empty()) + { + cmCPackLogger(cmCPackLog::LOG_ERROR, + "CPACK_DMG_SLA_LANGUAGES set but empty" + << std::endl); + return 0; + } + for(size_t i = 0; i < languages.size(); ++i) + { + std::string license = slaDirectory + "/" + languages[i] + ".license.txt"; + if (!cmSystemTools::FileExists(license)) + { + cmCPackLogger(cmCPackLog::LOG_ERROR, + "Missing license file " << languages[i] << ".license.txt" + << std::endl); + return 0; + } + std::string menu = slaDirectory + "/" + languages[i] + ".menu.txt"; + if (!cmSystemTools::FileExists(menu)) + { + cmCPackLogger(cmCPackLog::LOG_ERROR, + "Missing menu file " << languages[i] << ".menu.txt" + << std::endl); + return 0; + } + } + } + return this->Superclass::InitializeInternal(); } @@ -190,6 +271,28 @@ bool cmCPackDragNDropGenerator::CopyFile(std::ostringstream& source, } //---------------------------------------------------------------------- +bool cmCPackDragNDropGenerator::CreateEmptyFile(std::ostringstream& target, + size_t size) +{ + cmsys::ofstream fout(target.str().c_str(), + std::ios::out | std::ios::binary); + if(!fout) + { + return false; + } + else + { + // Seek to desired size - 1 byte + fout.seekp(size - 1, std::ios_base::beg); + char byte = 0; + // Write one byte to ensure file grows + fout.write(&byte, 1); + } + + return true; +} + +//---------------------------------------------------------------------- bool cmCPackDragNDropGenerator::RunCommand(std::ostringstream& command, std::string* output) { @@ -246,12 +349,27 @@ int cmCPackDragNDropGenerator::CreateDMG(const std::string& src_dir, this->GetOption("CPACK_DMG_DS_STORE") ? this->GetOption("CPACK_DMG_DS_STORE") : ""; + const std::string cpack_dmg_languages = + this->GetOption("CPACK_DMG_SLA_LANGUAGES") + ? this->GetOption("CPACK_DMG_SLA_LANGUAGES") : ""; + + const std::string cpack_dmg_ds_store_setup_script = + this->GetOption("CPACK_DMG_DS_STORE_SETUP_SCRIPT") + ? this->GetOption("CPACK_DMG_DS_STORE_SETUP_SCRIPT") : ""; + // only put license on dmg if is user provided if(!cpack_license_file.empty() && cpack_license_file.find("CPack.GenericLicense.txt") != std::string::npos) - { + { + cpack_license_file = ""; + } + + // use sla_dir if both sla_dir and license_file are set + if(!cpack_license_file.empty() && + !slaDirectory.empty()) + { cpack_license_file = ""; - } + } // The staging directory contains everything that will end-up inside the // final disk image ... @@ -307,13 +425,18 @@ int cmCPackDragNDropGenerator::CreateDMG(const std::string& src_dir, } // Optionally add a custom background image ... + // Make sure the background file type is the same as the custom image + // and that the file is hidden so it doesn't show up. if(!cpack_dmg_background_image.empty()) { + const std::string extension = + cmSystemTools::GetFilenameLastExtension(cpack_dmg_background_image); std::ostringstream package_background_source; package_background_source << cpack_dmg_background_image; std::ostringstream package_background_destination; - package_background_destination << staging.str() << "/background.png"; + package_background_destination << staging.str() + << "/.background/background" << extension; if(!this->CopyFile(package_background_source, package_background_destination)) @@ -325,18 +448,22 @@ int cmCPackDragNDropGenerator::CreateDMG(const std::string& src_dir, return 0; } + } - std::ostringstream temp_background_hiding_command; - temp_background_hiding_command << this->GetOption("CPACK_COMMAND_SETFILE"); - temp_background_hiding_command << " -a V \""; - temp_background_hiding_command << package_background_destination.str(); - temp_background_hiding_command << "\""; + bool remount_image = !cpack_package_icon.empty() || + !cpack_dmg_ds_store_setup_script.empty(); - if(!this->RunCommand(temp_background_hiding_command)) + // Create 1 MB dummy padding file in staging area when we need to remount + // image, so we have enough space for storing changes ... + if(remount_image) + { + std::ostringstream dummy_padding; + dummy_padding << staging.str() << "/.dummy-padding-file"; + if(!this->CreateEmptyFile(dummy_padding, 1048576)) { - cmCPackLogger(cmCPackLog::LOG_ERROR, - "Error setting attributes on disk volume background image." - << std::endl); + cmCPackLogger(cmCPackLog::LOG_ERROR, + "Error creating dummy padding file." + << std::endl); return 0; } @@ -365,10 +492,11 @@ int cmCPackDragNDropGenerator::CreateDMG(const std::string& src_dir, return 0; } - // Optionally set the custom icon flag for the image ... - if(!cpack_package_icon.empty()) + if(remount_image) { - std::ostringstream temp_mount; + // Store that we have a failure so that we always unmount the image + // before we exit. + bool had_error = false; std::ostringstream attach_command; attach_command << this->GetOption("CPACK_COMMAND_HDIUTIL"); @@ -387,20 +515,57 @@ int cmCPackDragNDropGenerator::CreateDMG(const std::string& src_dir, cmsys::RegularExpression mountpoint_regex(".*(/Volumes/[^\n]+)\n.*"); mountpoint_regex.find(attach_output.c_str()); + std::ostringstream temp_mount; temp_mount << mountpoint_regex.match(1); - std::ostringstream setfile_command; - setfile_command << this->GetOption("CPACK_COMMAND_SETFILE"); - setfile_command << " -a C"; - setfile_command << " \"" << temp_mount.str() << "\""; - - if(!this->RunCommand(setfile_command)) + // Remove dummy padding file so we have enough space on RW image ... + std::ostringstream dummy_padding; + dummy_padding << temp_mount.str() << "/.dummy-padding-file"; + if(!cmSystemTools::RemoveFile(dummy_padding.str())) { cmCPackLogger(cmCPackLog::LOG_ERROR, - "Error assigning custom icon to temporary disk image." + "Error removing dummy padding file." << std::endl); - return 0; + had_error = true; + } + + // Optionally set the custom icon flag for the image ... + if(!had_error && !cpack_package_icon.empty()) + { + std::ostringstream setfile_command; + setfile_command << this->GetOption("CPACK_COMMAND_SETFILE"); + setfile_command << " -a C"; + setfile_command << " \"" << temp_mount.str() << "\""; + + if(!this->RunCommand(setfile_command)) + { + cmCPackLogger(cmCPackLog::LOG_ERROR, + "Error assigning custom icon to temporary disk image." + << std::endl); + + had_error = true; + } + } + + // Optionally we can execute a custom apple script to generate + // the .DS_Store for the volume folder ... + if(!had_error && !cpack_dmg_ds_store_setup_script.empty()) + { + std::ostringstream setup_script_command; + setup_script_command << "osascript" + << " \"" << cpack_dmg_ds_store_setup_script << "\"" + << " \"" << cpack_dmg_volume_name << "\""; + std::string error; + if(!this->RunCommand(setup_script_command, &error)) + { + cmCPackLogger(cmCPackLog::LOG_ERROR, + "Error executing custom script on disk image." << std::endl + << error + << std::endl); + + had_error = true; + } } std::ostringstream detach_command; @@ -416,56 +581,129 @@ int cmCPackDragNDropGenerator::CreateDMG(const std::string& src_dir, return 0; } + + if(had_error) + { + return 0; + } } - if(!cpack_license_file.empty()) - { + if(!cpack_license_file.empty() || !slaDirectory.empty()) + { + // Use old hardcoded style if sla_dir is not set + bool oldStyle = slaDirectory.empty(); std::string sla_r = this->GetOption("CPACK_TOPLEVEL_DIRECTORY"); sla_r += "/sla.r"; - cmsys::ifstream ifs; - ifs.open(cpack_license_file.c_str()); - if(ifs.is_open()) - { - cmGeneratedFileStream osf(sla_r.c_str()); - osf << "#include <CoreServices/CoreServices.r>\n\n"; - osf << SLAHeader; - osf << "\n"; - osf << "data 'TEXT' (5002, \"English\") {\n"; - while(ifs.good()) + std::vector<std::string> languages; + if(!oldStyle) { - std::string line; - std::getline(ifs, line); - // escape quotes - std::string::size_type pos = line.find('\"'); - while(pos != std::string::npos) + cmSystemTools::ExpandListArgument(cpack_dmg_languages, languages); + } + + cmGeneratedFileStream ofs(sla_r.c_str()); + ofs << "#include <CoreServices/CoreServices.r>\n\n"; + if(oldStyle) + { + ofs << SLAHeader; + ofs << "\n"; + } + else + { + /* + * LPic Layout + * (https://github.com/pypt/dmg-add-license/blob/master/main.c) + * as far as I can tell (no official documentation seems to exist): + * struct LPic { + * uint16_t default_language; // points to a resid, defaulting to 0, + * // which is the first set language + * uint16_t length; + * struct { + * uint16_t language_code; + * uint16_t resid; + * uint16_t encoding; // Encoding from TextCommon.h, + * // forcing MacRoman (0) for now. Might need to + * // allow overwrite per license by user later + * } item[1]; + * } + */ + + // Create vector first for readability, then iterate to write to ofs + std::vector<uint16_t> header_data; + header_data.push_back(0); + header_data.push_back(languages.size()); + for(size_t i = 0; i < languages.size(); ++i) { - line.replace(pos, 1, "\\\""); - pos = line.find('\"', pos+2); + CFStringRef language_cfstring = CFStringCreateWithCString( + NULL, languages[i].c_str(), kCFStringEncodingUTF8); + CFStringRef iso_language = + CFLocaleCreateCanonicalLanguageIdentifierFromString( + NULL, language_cfstring); + if (!iso_language) + { + cmCPackLogger(cmCPackLog::LOG_ERROR, + languages[i] << " is not a recognized language" + << std::endl); + } + char *iso_language_cstr = (char *) malloc(65); + CFStringGetCString(iso_language, iso_language_cstr, 64, + kCFStringEncodingMacRoman); + LangCode lang = 0; + RegionCode region = 0; + OSStatus err = LocaleStringToLangAndRegionCodes(iso_language_cstr, + &lang, ®ion); + if (err != noErr) + { + cmCPackLogger(cmCPackLog::LOG_ERROR, + "No language/region code available for " << iso_language_cstr + << std::endl); + free(iso_language_cstr); + return 0; + } + free(iso_language_cstr); + header_data.push_back(region); + header_data.push_back(i); + header_data.push_back(0); } - // break up long lines to avoid Rez errors - std::vector<std::string> lines; - const size_t max_line_length = 512; - for(size_t i=0; i<line.size(); i+= max_line_length) + ofs << "data 'LPic' (5000) {\n"; + ofs << std::hex << std::uppercase << std::setfill('0'); + + for(size_t i = 0; i < header_data.size(); ++i) + { + if(i % 8 == 0) { - int line_length = max_line_length; - if(i+max_line_length > line.size()) - line_length = line.size()-i; - lines.push_back(line.substr(i, line_length)); + ofs << " $\""; } - for(size_t i=0; i<lines.size(); i++) + ofs << std::setw(4) << header_data[i]; + + if(i % 8 == 7 || i == header_data.size() - 1) { - osf << " \"" << lines[i] << "\"\n"; + ofs << "\"\n"; } - osf << " \"\\n\"\n"; + else + { + ofs << " "; + } + } + ofs << "};\n\n"; + // Reset ofs options + ofs << std::dec << std::nouppercase << std::setfill(' '); } - osf << "};\n"; - osf << "\n"; - osf << SLASTREnglish; - ifs.close(); - osf.close(); - } + + if(oldStyle) + { + WriteLicense(ofs, 0, "", cpack_license_file); + } + else + { + for(size_t i = 0; i < languages.size(); ++i) + { + WriteLicense(ofs, i + 5000, languages[i]); + } + } + + ofs.Close(); // convert to UDCO std::string temp_udco = this->GetOption("CPACK_TOPLEVEL_DIRECTORY"); @@ -539,7 +777,7 @@ int cmCPackDragNDropGenerator::CreateDMG(const std::string& src_dir, } temp_image = temp_udco; - } + } // Create the final compressed read-only disk image ... @@ -607,3 +845,126 @@ cmCPackDragNDropGenerator::GetComponentInstallDirNameSuffix( return GetComponentPackageFileName(package_file_name, componentName, false); } + +void +cmCPackDragNDropGenerator::WriteLicense(cmGeneratedFileStream& outputStream, + int licenseNumber, std::string licenseLanguage, std::string licenseFile) +{ + if(!licenseFile.empty()) + { + licenseNumber = 5002; + licenseLanguage = "English"; + } + + // License header + outputStream << "data 'TEXT' (" << licenseNumber << ", \"" + << licenseLanguage << "\") {\n"; + // License body + std::string actual_license = !licenseFile.empty() ? licenseFile : + (slaDirectory + "/" + licenseLanguage + ".license.txt"); + cmsys::ifstream license_ifs; + license_ifs.open(actual_license.c_str()); + if(license_ifs.is_open()) + { + while(license_ifs.good()) + { + std::string line; + std::getline(license_ifs, line); + if(!line.empty()) + { + EscapeQuotes(line); + std::vector<std::string> lines; + BreakLongLine(line, lines); + for(size_t i = 0; i < lines.size(); ++i) + { + outputStream << " \"" << lines[i] << "\"\n"; + } + } + outputStream << " \"\\n\"\n"; + } + license_ifs.close(); + } + + // End of License + outputStream << "};\n\n"; + if(!licenseFile.empty()) + { + outputStream << SLASTREnglish; + } + else + { + // Menu header + outputStream << "resource 'STR#' (" << licenseNumber << ", \"" + << licenseLanguage << "\") {\n"; + outputStream << " {\n"; + + // Menu body + cmsys::ifstream menu_ifs; + menu_ifs.open((slaDirectory+"/"+licenseLanguage+".menu.txt").c_str()); + if(menu_ifs.is_open()) + { + size_t lines_written = 0; + while(menu_ifs.good()) + { + // Lines written from original file, not from broken up lines + std::string line; + std::getline(menu_ifs, line); + if(!line.empty()) + { + EscapeQuotes(line); + std::vector<std::string> lines; + BreakLongLine(line, lines); + for(size_t i = 0; i < lines.size(); ++i) + { + std::string comma; + // We need a comma after every complete string, + // but not on the very last line + if(lines_written != 8 && i == lines.size() - 1) + { + comma = ","; + } + else + { + comma = ""; + } + outputStream << " \"" << lines[i] << "\"" << comma << "\n"; + } + ++lines_written; + } + } + menu_ifs.close(); + } + + //End of menu + outputStream << " }\n"; + outputStream << "};\n"; + outputStream << "\n"; + } +} + +void +cmCPackDragNDropGenerator::BreakLongLine(const std::string& line, + std::vector<std::string>& lines) +{ + const size_t max_line_length = 512; + for(size_t i = 0; i < line.size(); i += max_line_length) + { + int line_length = max_line_length; + if(i + max_line_length > line.size()) + { + line_length = line.size() - i; + } + lines.push_back(line.substr(i, line_length)); + } +} + +void +cmCPackDragNDropGenerator::EscapeQuotes(std::string& line) +{ + std::string::size_type pos = line.find('\"'); + while(pos != std::string::npos) + { + line.replace(pos, 1, "\\\""); + pos = line.find('\"', pos + 2); + } +} diff --git a/Source/CPack/cmCPackDragNDropGenerator.h b/Source/CPack/cmCPackDragNDropGenerator.h index 1c84d49..53d38c4 100644 --- a/Source/CPack/cmCPackDragNDropGenerator.h +++ b/Source/CPack/cmCPackDragNDropGenerator.h @@ -15,6 +15,8 @@ #include "cmCPackGenerator.h" +class cmGeneratedFileStream; + /** \class cmCPackDragNDropGenerator * \brief A generator for OSX drag-n-drop installs */ @@ -34,6 +36,7 @@ protected: bool CopyFile(std::ostringstream& source, std::ostringstream& target); + bool CreateEmptyFile(std::ostringstream& target, size_t size); bool RunCommand(std::ostringstream& command, std::string* output = 0); std::string @@ -42,6 +45,15 @@ protected: int CreateDMG(const std::string& src_dir, const std::string& output_file); std::string InstallPrefix; + +private: + std::string slaDirectory; + + void WriteLicense(cmGeneratedFileStream& outputStream, int licenseNumber, + std::string licenseLanguage, std::string licenseFile = ""); + void BreakLongLine(const std::string& line, + std::vector<std::string>& lines); + void EscapeQuotes(std::string& line); }; #endif diff --git a/Source/CPack/cmCPackGenerator.cxx b/Source/CPack/cmCPackGenerator.cxx index def9fc7..22d4bf0 100644 --- a/Source/CPack/cmCPackGenerator.cxx +++ b/Source/CPack/cmCPackGenerator.cxx @@ -16,7 +16,6 @@ #include "cmCPackLog.h" #include "cmake.h" #include "cmGlobalGenerator.h" -#include "cmLocalGenerator.h" #include "cmGeneratedFileStream.h" #include "cmCPackComponentGroup.h" #include "cmXMLSafe.h" @@ -718,13 +717,12 @@ int cmCPackGenerator::InstallProjectViaInstallCMakeProjects( cmake cm; cm.SetHomeDirectory(""); cm.SetHomeOutputDirectory(""); + cm.GetCurrentSnapshot().SetDefaultDefinitions(); cm.AddCMakePaths(); cm.SetProgressCallback(cmCPackGeneratorProgress, this); cmGlobalGenerator gg(&cm); cmsys::auto_ptr<cmMakefile> mf( new cmMakefile(&gg, cm.GetCurrentSnapshot())); - cmsys::auto_ptr<cmLocalGenerator> lg( - gg.CreateLocalGenerator(mf.get())); std::string realInstallDirectory = tempInstallDirectory; if ( !installSubDirectory.empty() && installSubDirectory != "/" ) { diff --git a/Source/CPack/cmCPackNSISGenerator.cxx b/Source/CPack/cmCPackNSISGenerator.cxx index 6cdda28..5ba639f 100644 --- a/Source/CPack/cmCPackNSISGenerator.cxx +++ b/Source/CPack/cmCPackNSISGenerator.cxx @@ -13,7 +13,6 @@ #include "cmCPackNSISGenerator.h" #include "cmGlobalGenerator.h" -#include "cmLocalGenerator.h" #include "cmSystemTools.h" #include "cmMakefile.h" #include "cmGeneratedFileStream.h" @@ -158,6 +157,28 @@ int cmCPackNSISGenerator::PackageFiles() installerIconCode.c_str()); } + if (this->IsSet("CPACK_NSIS_MUI_WELCOMEFINISHPAGE_BITMAP")) + { + std::string installerBitmapCode = + "!define MUI_WELCOMEFINISHPAGE_BITMAP \""; + installerBitmapCode += + this->GetOption("CPACK_NSIS_MUI_WELCOMEFINISHPAGE_BITMAP"); + installerBitmapCode += "\"\n"; + this->SetOptionIfNotSet("CPACK_NSIS_INSTALLER_MUI_WELCOMEFINISH_CODE", + installerBitmapCode.c_str()); + } + + if (this->IsSet("CPACK_NSIS_MUI_UNWELCOMEFINISHPAGE_BITMAP")) + { + std::string installerBitmapCode = + "!define MUI_UNWELCOMEFINISHPAGE_BITMAP \""; + installerBitmapCode += + this->GetOption("CPACK_NSIS_MUI_UNWELCOMEFINISHPAGE_BITMAP"); + installerBitmapCode += "\"\n"; + this->SetOptionIfNotSet("CPACK_NSIS_INSTALLER_MUI_UNWELCOMEFINISH_CODE", + installerBitmapCode.c_str()); + } + if(this->IsSet("CPACK_NSIS_MUI_FINISHPAGE_RUN")) { std::string installerRunCode = "!define MUI_FINISHPAGE_RUN \"$INSTDIR\\"; diff --git a/Source/CPack/cmCPackOSXX11Generator.cxx b/Source/CPack/cmCPackOSXX11Generator.cxx index d533af8..8940f54 100644 --- a/Source/CPack/cmCPackOSXX11Generator.cxx +++ b/Source/CPack/cmCPackOSXX11Generator.cxx @@ -13,7 +13,6 @@ #include "cmake.h" #include "cmGlobalGenerator.h" -#include "cmLocalGenerator.h" #include "cmSystemTools.h" #include "cmMakefile.h" #include "cmGeneratedFileStream.h" diff --git a/Source/CPack/cmCPackPackageMakerGenerator.cxx b/Source/CPack/cmCPackPackageMakerGenerator.cxx index 880663f..8fdc036 100644 --- a/Source/CPack/cmCPackPackageMakerGenerator.cxx +++ b/Source/CPack/cmCPackPackageMakerGenerator.cxx @@ -13,7 +13,6 @@ #include "cmake.h" #include "cmGlobalGenerator.h" -#include "cmLocalGenerator.h" #include "cmSystemTools.h" #include "cmMakefile.h" #include "cmGeneratedFileStream.h" diff --git a/Source/CPack/cmCPackSTGZGenerator.cxx b/Source/CPack/cmCPackSTGZGenerator.cxx index 109dcb7..68b893f 100644 --- a/Source/CPack/cmCPackSTGZGenerator.cxx +++ b/Source/CPack/cmCPackSTGZGenerator.cxx @@ -14,7 +14,6 @@ #include "cmake.h" #include "cmGlobalGenerator.h" -#include "cmLocalGenerator.h" #include "cmSystemTools.h" #include "cmMakefile.h" #include "cmCPackLog.h" diff --git a/Source/CPack/cpack.cxx b/Source/CPack/cpack.cxx index cb9cbc4..c08897f 100644 --- a/Source/CPack/cpack.cxx +++ b/Source/CPack/cpack.cxx @@ -18,7 +18,6 @@ #include "cmCPackGenerator.h" #include "cmake.h" #include "cmGlobalGenerator.h" -#include "cmLocalGenerator.h" #include "cmMakefile.h" #include "cmCPackLog.h" @@ -200,12 +199,11 @@ int main (int argc, char const* const* argv) cmake cminst; cminst.SetHomeDirectory(""); cminst.SetHomeOutputDirectory(""); + cminst.GetCurrentSnapshot().SetDefaultDefinitions(); cminst.GetState()->RemoveUnscriptableCommands(); cmGlobalGenerator cmgg(&cminst); cmsys::auto_ptr<cmMakefile> globalMF( new cmMakefile(&cmgg, cminst.GetCurrentSnapshot())); - cmsys::auto_ptr<cmLocalGenerator> cmlg( - cmgg.CreateLocalGenerator(globalMF.get())); #if defined(__CYGWIN__) globalMF->AddDefinition("CMAKE_LEGACY_CYGWIN_WIN32", "0"); #endif diff --git a/Source/CTest/cmCTestBuildHandler.cxx b/Source/CTest/cmCTestBuildHandler.cxx index 6dbb245..0d74f48 100644 --- a/Source/CTest/cmCTestBuildHandler.cxx +++ b/Source/CTest/cmCTestBuildHandler.cxx @@ -15,7 +15,6 @@ #include "cmCTest.h" #include "cmake.h" #include "cmMakefile.h" -#include "cmLocalGenerator.h" #include "cmGlobalGenerator.h" #include "cmGeneratedFileStream.h" #include "cmXMLWriter.h" diff --git a/Source/CTest/cmCTestCoverageHandler.cxx b/Source/CTest/cmCTestCoverageHandler.cxx index 20807c8..2c2cd48 100644 --- a/Source/CTest/cmCTestCoverageHandler.cxx +++ b/Source/CTest/cmCTestCoverageHandler.cxx @@ -820,11 +820,26 @@ int cmCTestCoverageHandler::HandleCoberturaCoverage( { cmParseCoberturaCoverage cov(*cont, this->CTest); - // Assume the coverage.xml is in the source directory - std::string coverageXMLFile = this->CTest->GetBinaryDir() + "/coverage.xml"; + // Assume the coverage.xml is in the binary directory + // check for the COBERTURADIR environment variable, + // if it doesn't exist or is empty, assume the + // binary directory is used. + std::string coverageXMLFile; + const char* covDir = cmSystemTools::GetEnv("COBERTURADIR"); + if(covDir && strlen(covDir) != 0) + { + coverageXMLFile = std::string(covDir); + } + else + { + coverageXMLFile = this->CTest->GetBinaryDir(); + } + // build the find file string with the directory from above + coverageXMLFile += "/coverage.xml"; if(cmSystemTools::FileExists(coverageXMLFile.c_str())) { + // If file exists, parse it cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT, "Parsing Cobertura XML file: " << coverageXMLFile << std::endl, this->Quiet); @@ -833,7 +848,7 @@ int cmCTestCoverageHandler::HandleCoberturaCoverage( else { cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT, - "Cannot find Cobertura XML file: " << coverageXMLFile + " Cannot find Cobertura XML file: " << coverageXMLFile << std::endl, this->Quiet); } return static_cast<int>(cont->TotalCoverage.size()); @@ -913,16 +928,33 @@ int cmCTestCoverageHandler::HandleJacocoCoverage( { cmParseJacocoCoverage cov = cmParseJacocoCoverage(*cont, this->CTest); - cmsys::Glob g; + + // Search in the source directory. + cmsys::Glob g1; std::vector<std::string> files; - g.SetRecurse(true); + g1.SetRecurse(true); std::string SourceDir = this->CTest->GetCTestConfiguration("SourceDirectory"); std::string coverageFile = SourceDir+ "/*jacoco.xml"; - g.FindFiles(coverageFile); - files=g.GetFiles(); + g1.FindFiles(coverageFile); + files = g1.GetFiles(); + + // ...and in the binary directory. + cmsys::Glob g2; + std::vector<std::string> binFiles; + g2.SetRecurse(true); + std::string binaryDir + = this->CTest->GetCTestConfiguration("BuildDirectory"); + std::string binCoverageFile = binaryDir+ "/*jacoco.xml"; + g2.FindFiles(binCoverageFile); + binFiles = g2.GetFiles(); + if (!binFiles.empty()) + { + files.insert(files.end(), binFiles.begin(), binFiles.end()); + } + if (!files.empty()) { cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT, @@ -2287,7 +2319,7 @@ int cmCTestCoverageHandler::RunBullseyeSourceSummary( { cper /= 2.0f; } - percent_coverage += cper; + percent_coverage += static_cast<double>(cper); float cmet = static_cast<float>(percentFunction + percentBranch); if(totalBranches > 0) { diff --git a/Source/CTest/cmCTestLaunch.cxx b/Source/CTest/cmCTestLaunch.cxx index fb0cce6..749a5be 100644 --- a/Source/CTest/cmCTestLaunch.cxx +++ b/Source/CTest/cmCTestLaunch.cxx @@ -728,7 +728,6 @@ int cmCTestLaunch::Main(int argc, const char* const argv[]) //---------------------------------------------------------------------------- #include "cmGlobalGenerator.h" -#include "cmLocalGenerator.h" #include "cmMakefile.h" #include "cmake.h" #include <cmsys/auto_ptr.hxx> @@ -737,10 +736,9 @@ void cmCTestLaunch::LoadConfig() cmake cm; cm.SetHomeDirectory(""); cm.SetHomeOutputDirectory(""); + cm.GetCurrentSnapshot().SetDefaultDefinitions(); cmGlobalGenerator gg(&cm); cmsys::auto_ptr<cmMakefile> mf(new cmMakefile(&gg, cm.GetCurrentSnapshot())); - cmsys::auto_ptr<cmLocalGenerator> lg( - gg.CreateLocalGenerator(mf.get())); std::string fname = this->LogDir; fname += "CTestLaunchConfig.cmake"; if(cmSystemTools::FileExists(fname.c_str()) && diff --git a/Source/CTest/cmCTestScriptHandler.cxx b/Source/CTest/cmCTestScriptHandler.cxx index c1ba279..ee15271 100644 --- a/Source/CTest/cmCTestScriptHandler.cxx +++ b/Source/CTest/cmCTestScriptHandler.cxx @@ -16,7 +16,6 @@ #include "cmake.h" #include "cmFunctionBlocker.h" #include "cmMakefile.h" -#include "cmLocalGenerator.h" #include "cmGlobalGenerator.h" #include "cmGeneratedFileStream.h" @@ -86,7 +85,6 @@ cmCTestScriptHandler::cmCTestScriptHandler() this->EmptyBinDir = false; this->EmptyBinDirOnce = false; this->Makefile = 0; - this->LocalGenerator = 0; this->CMake = 0; this->GlobalGenerator = 0; @@ -128,9 +126,6 @@ void cmCTestScriptHandler::Initialize() delete this->Makefile; this->Makefile = 0; - delete this->LocalGenerator; - this->LocalGenerator = 0; - delete this->GlobalGenerator; this->GlobalGenerator = 0; @@ -141,7 +136,6 @@ void cmCTestScriptHandler::Initialize() cmCTestScriptHandler::~cmCTestScriptHandler() { delete this->Makefile; - delete this->LocalGenerator; delete this->GlobalGenerator; delete this->CMake; } @@ -179,15 +173,14 @@ int cmCTestScriptHandler::ProcessHandler() void cmCTestScriptHandler::UpdateElapsedTime() { - if (this->LocalGenerator) + if (this->Makefile) { // set the current elapsed time char timeString[20]; int itime = static_cast<unsigned int>(cmSystemTools::GetTime() - this->ScriptStartTime); sprintf(timeString,"%i",itime); - this->LocalGenerator->GetMakefile()->AddDefinition("CTEST_ELAPSED_TIME", - timeString); + this->Makefile->AddDefinition("CTEST_ELAPSED_TIME", timeString); } } @@ -316,28 +309,23 @@ void cmCTestScriptHandler::CreateCMake() { delete this->CMake; delete this->GlobalGenerator; - delete this->LocalGenerator; delete this->Makefile; } this->CMake = new cmake; this->CMake->SetHomeDirectory(""); this->CMake->SetHomeOutputDirectory(""); + this->CMake->GetCurrentSnapshot().SetDefaultDefinitions(); this->CMake->AddCMakePaths(); this->GlobalGenerator = new cmGlobalGenerator(this->CMake); cmState::Snapshot snapshot = this->CMake->GetCurrentSnapshot(); + std::string cwd = cmSystemTools::GetCurrentWorkingDirectory(); + snapshot.GetDirectory().SetCurrentSource(cwd); + snapshot.GetDirectory().SetCurrentBinary(cwd); this->Makefile = new cmMakefile(this->GlobalGenerator, snapshot); - this->LocalGenerator = - this->GlobalGenerator->CreateLocalGenerator(this->Makefile); this->CMake->SetProgressCallback(ctestScriptProgressCallback, this->CTest); - // Set CMAKE_CURRENT_SOURCE_DIR and CMAKE_CURRENT_BINARY_DIR. - // Also, some commands need Makefile->GetCurrentSourceDirectory(). - std::string cwd = cmSystemTools::GetCurrentWorkingDirectory(); - this->Makefile->SetCurrentSourceDirectory(cwd); - this->Makefile->SetCurrentBinaryDirectory(cwd); - // remove all cmake commands which are not scriptable, since they can't be // used in ctest scripts this->CMake->GetState()->RemoveUnscriptableCommands(); diff --git a/Source/CTest/cmCTestScriptHandler.h b/Source/CTest/cmCTestScriptHandler.h index 42c2f20..c9d0b6a 100644 --- a/Source/CTest/cmCTestScriptHandler.h +++ b/Source/CTest/cmCTestScriptHandler.h @@ -18,7 +18,6 @@ #include "cmListFileCache.h" class cmMakefile; -class cmLocalGenerator; class cmGlobalGenerator; class cmake; class cmCTestCommand; @@ -166,7 +165,6 @@ private: double ScriptStartTime; cmMakefile *Makefile; - cmLocalGenerator *LocalGenerator; cmGlobalGenerator *GlobalGenerator; cmake *CMake; }; diff --git a/Source/CTest/cmCTestStartCommand.cxx b/Source/CTest/cmCTestStartCommand.cxx index e19e4f4..36576c5 100644 --- a/Source/CTest/cmCTestStartCommand.cxx +++ b/Source/CTest/cmCTestStartCommand.cxx @@ -12,7 +12,6 @@ #include "cmCTestStartCommand.h" #include "cmCTest.h" -#include "cmLocalGenerator.h" #include "cmGlobalGenerator.h" #include "cmCTestVC.h" #include "cmGeneratedFileStream.h" diff --git a/Source/CTest/cmCTestTestHandler.cxx b/Source/CTest/cmCTestTestHandler.cxx index f9678e7..a8f983f 100644 --- a/Source/CTest/cmCTestTestHandler.cxx +++ b/Source/CTest/cmCTestTestHandler.cxx @@ -24,7 +24,6 @@ #include <cmsys/FStream.hxx> #include "cmMakefile.h" #include "cmGlobalGenerator.h" -#include "cmLocalGenerator.h" #include "cmCommand.h" #include "cmSystemTools.h" #include "cmXMLWriter.h" @@ -580,7 +579,7 @@ int cmCTestTestHandler::ProcessHandler() } cmCTestLog(this->CTest, HANDLER_OUTPUT, std::endl - << static_cast<int>(percent + .5) << "% tests passed, " + << static_cast<int>(percent + .5f) << "% tests passed, " << failed.size() << " tests failed out of " << total << std::endl); if(this->CTest->GetLabelSummary()) @@ -1591,10 +1590,9 @@ void cmCTestTestHandler::GetListOfTests() cmake cm; cm.SetHomeDirectory(""); cm.SetHomeOutputDirectory(""); + cm.GetCurrentSnapshot().SetDefaultDefinitions(); cmGlobalGenerator gg(&cm); cmsys::auto_ptr<cmMakefile> mf(new cmMakefile(&gg, cm.GetCurrentSnapshot())); - cmsys::auto_ptr<cmLocalGenerator> lg( - gg.CreateLocalGenerator(mf.get())); mf->AddDefinition("CTEST_CONFIGURATION_TYPE", this->CTest->GetConfigType().c_str()); diff --git a/Source/CTest/cmCTestUpdateHandler.cxx b/Source/CTest/cmCTestUpdateHandler.cxx index 963e501..bf2f34a 100644 --- a/Source/CTest/cmCTestUpdateHandler.cxx +++ b/Source/CTest/cmCTestUpdateHandler.cxx @@ -15,7 +15,6 @@ #include "cmCTest.h" #include "cmake.h" #include "cmMakefile.h" -#include "cmLocalGenerator.h" #include "cmGlobalGenerator.h" #include "cmVersion.h" #include "cmGeneratedFileStream.h" diff --git a/Source/QtDialog/CMakeSetupDialog.cxx b/Source/QtDialog/CMakeSetupDialog.cxx index 03417f3..748dd7d 100644 --- a/Source/QtDialog/CMakeSetupDialog.cxx +++ b/Source/QtDialog/CMakeSetupDialog.cxx @@ -734,6 +734,7 @@ bool CMakeSetupDialog::setupFirstConfigure() { dialog.saveToSettings(); this->CMakeThread->cmakeInstance()->setGenerator(dialog.getGenerator()); + this->CMakeThread->cmakeInstance()->setToolset(dialog.getToolset()); QCMakeCacheModel* m = this->CacheValues->cacheModel(); diff --git a/Source/QtDialog/FirstConfigure.cxx b/Source/QtDialog/FirstConfigure.cxx index 6de9f00..61aad72 100644 --- a/Source/QtDialog/FirstConfigure.cxx +++ b/Source/QtDialog/FirstConfigure.cxx @@ -15,6 +15,11 @@ StartCompilerSetup::StartCompilerSetup(QWidget* p) l->addWidget(new QLabel(tr("Specify the generator for this project"))); this->GeneratorOptions = new QComboBox(this); l->addWidget(this->GeneratorOptions); + + // Add the ability to specify toolset (-T parameter) + ToolsetFrame = CreateToolsetWidgets(); + l->addWidget(ToolsetFrame); + l->addSpacing(6); this->CompilerSetupOptions[0] = new QRadioButton(tr("Use default native compilers"), this); @@ -36,17 +41,51 @@ StartCompilerSetup::StartCompilerSetup(QWidget* p) this, SLOT(onSelectionChanged(bool))); QObject::connect(this->CompilerSetupOptions[3], SIGNAL(toggled(bool)), this, SLOT(onSelectionChanged(bool))); + QObject::connect(GeneratorOptions, + SIGNAL(currentIndexChanged(QString const&)), + this, SLOT(onGeneratorChanged(QString const&))); +} + +QFrame* StartCompilerSetup::CreateToolsetWidgets() +{ + QFrame* frame = new QFrame(this); + QVBoxLayout* l = new QVBoxLayout(frame); + l->setContentsMargins(0, 0, 0, 0); + + ToolsetLabel = new QLabel(tr("Optional toolset to use (-T parameter)")); + l->addWidget(ToolsetLabel); + + Toolset = new QLineEdit(frame); + l->addWidget(Toolset); + + return frame; } StartCompilerSetup::~StartCompilerSetup() { } -void StartCompilerSetup::setGenerators(const QStringList& gens) +void StartCompilerSetup::setGenerators( + std::vector<cmake::GeneratorInfo> const& gens) { this->GeneratorOptions->clear(); - this->GeneratorOptions->addItems(gens); -}; + + QStringList generator_list; + + std::vector<cmake::GeneratorInfo>::const_iterator it; + for (it = gens.begin(); it != gens.end(); ++it) + { + generator_list.append(QString::fromLocal8Bit(it->name.c_str())); + + if (it->supportsToolset) + { + this->GeneratorsSupportingToolset.append( + QString::fromLocal8Bit(it->name.c_str())); + } + } + + this->GeneratorOptions->addItems(generator_list); +} void StartCompilerSetup::setCurrentGenerator(const QString& gen) { @@ -62,6 +101,11 @@ QString StartCompilerSetup::getGenerator() const return this->GeneratorOptions->currentText(); }; +QString StartCompilerSetup::getToolset() const +{ + return this->Toolset->text(); +}; + bool StartCompilerSetup::defaultSetup() const { return this->CompilerSetupOptions[0]->isChecked(); @@ -88,6 +132,18 @@ void StartCompilerSetup::onSelectionChanged(bool on) selectionChanged(); } +void StartCompilerSetup::onGeneratorChanged(QString const& name) +{ + if (GeneratorsSupportingToolset.contains(name)) + { + ToolsetFrame->show(); + } + else + { + ToolsetFrame->hide(); + } +} + int StartCompilerSetup::nextId() const { if(compilerSetup()) @@ -325,7 +381,8 @@ FirstConfigure::~FirstConfigure() { } -void FirstConfigure::setGenerators(const QStringList& gens) +void FirstConfigure::setGenerators( + std::vector<cmake::GeneratorInfo> const& gens) { this->mStartCompilerSetupPage->setGenerators(gens); } @@ -335,6 +392,11 @@ QString FirstConfigure::getGenerator() const return this->mStartCompilerSetupPage->getGenerator(); } +QString FirstConfigure::getToolset() const +{ + return this->mStartCompilerSetupPage->getToolset(); +} + void FirstConfigure::loadFromSettings() { QSettings settings; diff --git a/Source/QtDialog/FirstConfigure.h b/Source/QtDialog/FirstConfigure.h index be390b0..09952b6 100644 --- a/Source/QtDialog/FirstConfigure.h +++ b/Source/QtDialog/FirstConfigure.h @@ -4,6 +4,7 @@ #include <QWizard> #include <QWizardPage> +#include "cmake.h" #include "ui_Compilers.h" #include "ui_CrossCompiler.h" @@ -27,9 +28,10 @@ class StartCompilerSetup : public QWizardPage public: StartCompilerSetup(QWidget* p); ~StartCompilerSetup(); - void setGenerators(const QStringList& gens); + void setGenerators(std::vector<cmake::GeneratorInfo> const& gens); void setCurrentGenerator(const QString& gen); QString getGenerator() const; + QString getToolset() const; bool defaultSetup() const; bool compilerSetup() const; @@ -43,10 +45,18 @@ class StartCompilerSetup : public QWizardPage protected slots: void onSelectionChanged(bool); + void onGeneratorChanged(QString const& name); protected: QComboBox* GeneratorOptions; QRadioButton* CompilerSetupOptions[4]; + QFrame* ToolsetFrame; + QLineEdit* Toolset; + QLabel* ToolsetLabel; + QStringList GeneratorsSupportingToolset; + + private: + QFrame* CreateToolsetWidgets(); }; //! the page that gives basic options for native compilers @@ -140,8 +150,9 @@ public: FirstConfigure(); ~FirstConfigure(); - void setGenerators(const QStringList& gens); + void setGenerators(std::vector<cmake::GeneratorInfo> const& gens); QString getGenerator() const; + QString getToolset() const; bool defaultSetup() const; bool compilerSetup() const; diff --git a/Source/QtDialog/QCMake.cxx b/Source/QtDialog/QCMake.cxx index 9edbb20..1fcb676 100644 --- a/Source/QtDialog/QCMake.cxx +++ b/Source/QtDialog/QCMake.cxx @@ -15,7 +15,6 @@ #include <QDir> #include <QCoreApplication> -#include "cmake.h" #include "cmState.h" #include "cmSystemTools.h" #include "cmExternalMakefileProjectGenerator.h" @@ -46,21 +45,23 @@ QCMake::QCMake(QObject* p) cmSystemTools::SetInterruptCallback(QCMake::interruptCallback, this); - std::vector<std::string> generators; + std::vector<cmake::GeneratorInfo> generators; this->CMakeInstance->GetRegisteredGenerators(generators); - std::vector<std::string>::iterator iter; - for(iter = generators.begin(); iter != generators.end(); ++iter) + + std::vector<cmake::GeneratorInfo>::const_iterator it; + for(it = generators.begin(); it != generators.end(); ++it) { // Skip the generator "KDevelop3", since there is also // "KDevelop3 - Unix Makefiles", which is the full and official name. // The short name is actually only still there since this was the name // in CMake 2.4, to keep "command line argument compatibility", but // this is not necessary in the GUI. - if (*iter == "KDevelop3") + if (it->name == "KDevelop3") { continue; } - this->AvailableGenerators.append(QString::fromLocal8Bit(iter->c_str())); + + this->AvailableGenerators.push_back(*it); } } @@ -96,6 +97,7 @@ void QCMake::setBinaryDirectory(const QString& _dir) emit this->binaryDirChanged(this->BinaryDirectory); cmState* state = this->CMakeInstance->GetState(); this->setGenerator(QString()); + this->setToolset(QString()); if(!this->CMakeInstance->LoadCache( this->BinaryDirectory.toLocal8Bit().data())) { @@ -124,6 +126,12 @@ void QCMake::setBinaryDirectory(const QString& _dir) CreateFullGeneratorName(gen, extraGen? extraGen : ""); this->setGenerator(QString::fromLocal8Bit(curGen.c_str())); } + + const char* toolset = state->GetCacheEntryValue("CMAKE_GENERATOR_TOOLSET"); + if (toolset) + { + this->setToolset(QString::fromLocal8Bit(toolset)); + } } } @@ -137,6 +145,15 @@ void QCMake::setGenerator(const QString& gen) } } +void QCMake::setToolset(const QString& toolset) +{ + if(this->Toolset != toolset) + { + this->Toolset = toolset; + emit this->toolsetChanged(this->Toolset); + } +} + void QCMake::configure() { #ifdef Q_OS_WIN @@ -148,7 +165,7 @@ void QCMake::configure() this->CMakeInstance->SetGlobalGenerator( this->CMakeInstance->CreateGlobalGenerator(this->Generator.toLocal8Bit().data())); this->CMakeInstance->SetGeneratorPlatform(""); - this->CMakeInstance->SetGeneratorToolset(""); + this->CMakeInstance->SetGeneratorToolset(this->Toolset.toLocal8Bit().data()); this->CMakeInstance->LoadCache(); this->CMakeInstance->SetSuppressDevWarnings(this->SuppressDevWarnings); this->CMakeInstance->SetWarnUninitialized(this->WarnUninitializedMode); @@ -396,9 +413,9 @@ QString QCMake::generator() const return this->Generator; } -QStringList QCMake::availableGenerators() const +std::vector<cmake::GeneratorInfo> const& QCMake::availableGenerators() const { - return this->AvailableGenerators; + return AvailableGenerators; } void QCMake::deleteCache() @@ -409,6 +426,7 @@ void QCMake::deleteCache() this->CMakeInstance->LoadCache(this->BinaryDirectory.toLocal8Bit().data()); // emit no generator and no properties this->setGenerator(QString()); + this->setToolset(QString()); QCMakePropertyList props = this->properties(); emit this->propertiesChanged(props); } diff --git a/Source/QtDialog/QCMake.h b/Source/QtDialog/QCMake.h index d910eb7..2d45da9 100644 --- a/Source/QtDialog/QCMake.h +++ b/Source/QtDialog/QCMake.h @@ -17,6 +17,8 @@ #pragma warning ( disable : 4512 ) #endif +#include <vector> + #include <QObject> #include <QString> #include <QVariant> @@ -25,7 +27,7 @@ #include <QMetaType> #include <QAtomicInt> -class cmake; +#include "cmake.h" /// struct to represent cmake properties in Qt /// Value is of type String or Bool @@ -73,6 +75,8 @@ public slots: void setBinaryDirectory(const QString& dir); /// set the desired generator to use void setGenerator(const QString& generator); + /// set the desired generator to use + void setToolset(const QString& toolset); /// do the configure step void configure(); /// generate the files @@ -104,7 +108,7 @@ public: /// get the current generator QString generator() const; /// get the available generators - QStringList availableGenerators() const; + std::vector<cmake::GeneratorInfo> const& availableGenerators() const; /// get whether to do debug output bool getDebugOutput() const; @@ -130,6 +134,8 @@ signals: void errorMessage(const QString& msg); /// signal when debug output changes void debugOutputChanged(bool); + /// signal when the toolset changes + void toolsetChanged(const QString& toolset); protected: cmake* CMakeInstance; @@ -147,7 +153,8 @@ protected: QString SourceDirectory; QString BinaryDirectory; QString Generator; - QStringList AvailableGenerators; + QString Toolset; + std::vector<cmake::GeneratorInfo> AvailableGenerators; QString CMakeExecutable; QAtomicInt InterruptFlag; }; diff --git a/Source/bindexplib.cxx b/Source/bindexplib.cxx index dc4db63..e7263ae 100644 --- a/Source/bindexplib.cxx +++ b/Source/bindexplib.cxx @@ -70,7 +70,7 @@ * Author: Valery Fine 16/09/96 (E-mail: fine@vxcern.cern.ch) *---------------------------------------------------------------------- */ - +#include "bindexplib.h" #include <cmsys/Encoding.hxx> #include <windows.h> #include <stdio.h> @@ -173,15 +173,17 @@ public: */ DumpSymbols(ObjectHeaderType* ih, - FILE* fout, bool is64) { + std::set<std::string>& symbols, + std::set<std::string>& dataSymbols, + bool is64) + :Symbols(symbols), DataSymbols(dataSymbols) + { this->ObjectImageHeader = ih; this->SymbolTable = (SymbolTableType*) ((DWORD_PTR)this->ObjectImageHeader + this->ObjectImageHeader->PointerToSymbolTable); - this->FileOut = fout; this->SectionHeaders = GetSectionHeaderOffset(this->ObjectImageHeader); - this->ImportFlag = true; this->SymbolCount = this->ObjectImageHeader->NumberOfSymbols; this->Is64Bit = is64; } @@ -296,10 +298,6 @@ public: symbol.erase(0,1); } } - if (this->ImportFlag) { - this->ImportFlag = false; - fprintf(this->FileOut,"EXPORTS \n"); - } /* Check whether it is "Scalar deleting destructor" and "Vector deleting destructor" @@ -319,11 +317,11 @@ public: SectionHeaders[pSymbolTable->SectionNumber-1].Characteristics; if (!pSymbolTable->Type && (SectChar & IMAGE_SCN_MEM_WRITE)) { // Read only (i.e. constants) must be excluded - fprintf(this->FileOut, "\t%s \t DATA\n", symbol.c_str()); + this->DataSymbols.insert(symbol); } else { if ( pSymbolTable->Type || !(SectChar & IMAGE_SCN_MEM_READ)) { - fprintf(this->FileOut, "\t%s\n", symbol.c_str()); + this->Symbols.insert(symbol); } else { // printf(" strange symbol: %s \n",symbol.c_str()); } @@ -340,11 +338,7 @@ public: symbol = stringTable + pSymbolTable->N.Name.Long; while (isspace(symbol[0])) symbol.erase(0,1); if (symbol[0] == '_') symbol.erase(0,1); - if (!this->ImportFlag) { - this->ImportFlag = true; - fprintf(this->FileOut,"IMPORTS \n"); - } - fprintf(this->FileOut, "\t%s DATA \n", symbol.c_str()+1); + this->DataSymbols.insert(symbol); } } @@ -357,8 +351,8 @@ public: } } private: - bool ImportFlag; - FILE* FileOut; + std::set<std::string>& Symbols; + std::set<std::string>& DataSymbols; DWORD_PTR SymbolCount; PIMAGE_SECTION_HEADER SectionHeaders; ObjectHeaderType* ObjectImageHeader; @@ -367,7 +361,9 @@ private: }; bool -DumpFile(const char* filename, FILE *fout) +DumpFile(const char* filename, + std::set<std::string>& symbols, + std::set<std::string>& dataSymbols) { HANDLE hFile; HANDLE hFileMapping; @@ -415,7 +411,7 @@ DumpFile(const char* filename, FILE *fout) * and IMAGE_FILE_HEADER.SizeOfOptionalHeader == 0; */ DumpSymbols<IMAGE_FILE_HEADER, IMAGE_SYMBOL> - symbolDumper((PIMAGE_FILE_HEADER) lpFileBase, fout, + symbolDumper((PIMAGE_FILE_HEADER) lpFileBase, symbols, dataSymbols, (dosHeader->e_magic == IMAGE_FILE_MACHINE_AMD64)); symbolDumper.DumpObjFile(); } else { @@ -424,8 +420,9 @@ DumpFile(const char* filename, FILE *fout) (cmANON_OBJECT_HEADER_BIGOBJ*) lpFileBase; if(h->Sig1 == 0x0 && h->Sig2 == 0xffff) { DumpSymbols<cmANON_OBJECT_HEADER_BIGOBJ, cmIMAGE_SYMBOL_EX> - symbolDumper((cmANON_OBJECT_HEADER_BIGOBJ*) lpFileBase, fout, - (dosHeader->e_magic == IMAGE_FILE_MACHINE_AMD64)); + symbolDumper((cmANON_OBJECT_HEADER_BIGOBJ*) lpFileBase, symbols, + dataSymbols, + (h->Machine == IMAGE_FILE_MACHINE_AMD64)); symbolDumper.DumpObjFile(); } else { printf("unrecognized file format in '%s'\n", filename); @@ -437,3 +434,27 @@ DumpFile(const char* filename, FILE *fout) CloseHandle(hFile); return true; } + +bool bindexplib::AddObjectFile(const char* filename) +{ + if(!DumpFile(filename, this->Symbols, this->DataSymbols)) + { + return false; + } + return true; +} + +void bindexplib::WriteFile(FILE* file) +{ + fprintf(file,"EXPORTS \n"); + for(std::set<std::string>::const_iterator i = this->DataSymbols.begin(); + i!= this->DataSymbols.end(); ++i) + { + fprintf(file, "\t%s \t DATA\n", i->c_str()); + } + for(std::set<std::string>::const_iterator i = this->Symbols.begin(); + i!= this->Symbols.end(); ++i) + { + fprintf(file, "\t%s\n", i->c_str()); + } +} diff --git a/Source/bindexplib.h b/Source/bindexplib.h new file mode 100644 index 0000000..8661a4a --- /dev/null +++ b/Source/bindexplib.h @@ -0,0 +1,29 @@ +/*============================================================================ + 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. +============================================================================*/ + +#ifndef bindexplib_h +#define bindexplib_h + +#include "cmStandardIncludes.h" + + +class bindexplib +{ +public: + bindexplib() {} + bool AddObjectFile(const char* filename); + void WriteFile(FILE* file); +private: + std::set<std::string> Symbols; + std::set<std::string> DataSymbols; +}; +#endif diff --git a/Source/cmAddDependenciesCommand.cxx b/Source/cmAddDependenciesCommand.cxx index 3a74946..01e5253 100644 --- a/Source/cmAddDependenciesCommand.cxx +++ b/Source/cmAddDependenciesCommand.cxx @@ -10,7 +10,6 @@ See the License for more information. ============================================================================*/ #include "cmAddDependenciesCommand.h" -#include "cmLocalGenerator.h" #include "cmGlobalGenerator.h" // cmDependenciesCommand diff --git a/Source/cmAddExecutableCommand.cxx b/Source/cmAddExecutableCommand.cxx index d15fc1e..a84bb9d 100644 --- a/Source/cmAddExecutableCommand.cxx +++ b/Source/cmAddExecutableCommand.cxx @@ -174,8 +174,8 @@ bool cmAddExecutableCommand this->SetError(e.str()); return false; } - cmTarget::TargetType type = aliasedTarget->GetType(); - if(type != cmTarget::EXECUTABLE) + cmState::TargetType type = aliasedTarget->GetType(); + if(type != cmState::EXECUTABLE) { std::ostringstream e; e << "cannot create ALIAS target \"" << exename @@ -192,7 +192,7 @@ bool cmAddExecutableCommand this->SetError(e.str()); return false; } - this->Makefile->AddAlias(exename, aliasedTarget); + this->Makefile->AddAlias(exename, aliasedName); return true; } @@ -210,7 +210,7 @@ bool cmAddExecutableCommand } // Create the imported target. - this->Makefile->AddImportedTarget(exename, cmTarget::EXECUTABLE, + this->Makefile->AddImportedTarget(exename, cmState::EXECUTABLE, importGlobal); return true; } diff --git a/Source/cmAddLibraryCommand.cxx b/Source/cmAddLibraryCommand.cxx index a844cf1..5296cbb 100644 --- a/Source/cmAddLibraryCommand.cxx +++ b/Source/cmAddLibraryCommand.cxx @@ -25,10 +25,10 @@ bool cmAddLibraryCommand } // Library type defaults to value of BUILD_SHARED_LIBS, if it exists, // otherwise it defaults to static library. - cmTarget::TargetType type = cmTarget::SHARED_LIBRARY; + cmState::TargetType type = cmState::SHARED_LIBRARY; if (cmSystemTools::IsOff(this->Makefile->GetDefinition("BUILD_SHARED_LIBS"))) { - type = cmTarget::STATIC_LIBRARY; + type = cmState::STATIC_LIBRARY; } bool excludeFromAll = false; bool importTarget = false; @@ -50,7 +50,7 @@ bool cmAddLibraryCommand std::string libType = *s; if(libType == "STATIC") { - if (type == cmTarget::INTERFACE_LIBRARY) + if (type == cmState::INTERFACE_LIBRARY) { std::ostringstream e; e << "INTERFACE library specified with conflicting STATIC type."; @@ -58,12 +58,12 @@ bool cmAddLibraryCommand return false; } ++s; - type = cmTarget::STATIC_LIBRARY; + type = cmState::STATIC_LIBRARY; haveSpecifiedType = true; } else if(libType == "SHARED") { - if (type == cmTarget::INTERFACE_LIBRARY) + if (type == cmState::INTERFACE_LIBRARY) { std::ostringstream e; e << "INTERFACE library specified with conflicting SHARED type."; @@ -71,12 +71,12 @@ bool cmAddLibraryCommand return false; } ++s; - type = cmTarget::SHARED_LIBRARY; + type = cmState::SHARED_LIBRARY; haveSpecifiedType = true; } else if(libType == "MODULE") { - if (type == cmTarget::INTERFACE_LIBRARY) + if (type == cmState::INTERFACE_LIBRARY) { std::ostringstream e; e << "INTERFACE library specified with conflicting MODULE type."; @@ -84,12 +84,12 @@ bool cmAddLibraryCommand return false; } ++s; - type = cmTarget::MODULE_LIBRARY; + type = cmState::MODULE_LIBRARY; haveSpecifiedType = true; } else if(libType == "OBJECT") { - if (type == cmTarget::INTERFACE_LIBRARY) + if (type == cmState::INTERFACE_LIBRARY) { std::ostringstream e; e << "INTERFACE library specified with conflicting OBJECT type."; @@ -97,12 +97,12 @@ bool cmAddLibraryCommand return false; } ++s; - type = cmTarget::OBJECT_LIBRARY; + type = cmState::OBJECT_LIBRARY; haveSpecifiedType = true; } else if(libType == "UNKNOWN") { - if (type == cmTarget::INTERFACE_LIBRARY) + if (type == cmState::INTERFACE_LIBRARY) { std::ostringstream e; e << "INTERFACE library specified with conflicting UNKNOWN type."; @@ -110,12 +110,12 @@ bool cmAddLibraryCommand return false; } ++s; - type = cmTarget::UNKNOWN_LIBRARY; + type = cmState::UNKNOWN_LIBRARY; haveSpecifiedType = true; } else if(libType == "ALIAS") { - if (type == cmTarget::INTERFACE_LIBRARY) + if (type == cmState::INTERFACE_LIBRARY) { std::ostringstream e; e << "INTERFACE library specified with conflicting ALIAS type."; @@ -149,12 +149,12 @@ bool cmAddLibraryCommand return false; } ++s; - type = cmTarget::INTERFACE_LIBRARY; + type = cmState::INTERFACE_LIBRARY; haveSpecifiedType = true; } else if(*s == "EXCLUDE_FROM_ALL") { - if (type == cmTarget::INTERFACE_LIBRARY) + if (type == cmState::INTERFACE_LIBRARY) { std::ostringstream e; e << "INTERFACE library may not be used with EXCLUDE_FROM_ALL."; @@ -174,7 +174,7 @@ bool cmAddLibraryCommand ++s; importGlobal = true; } - else if(type == cmTarget::INTERFACE_LIBRARY && *s == "GLOBAL") + else if(type == cmState::INTERFACE_LIBRARY && *s == "GLOBAL") { std::ostringstream e; e << "GLOBAL option may only be used with IMPORTED libraries."; @@ -187,7 +187,7 @@ bool cmAddLibraryCommand } } - if (type == cmTarget::INTERFACE_LIBRARY) + if (type == cmState::INTERFACE_LIBRARY) { if (s != args.end()) { @@ -220,7 +220,7 @@ bool cmAddLibraryCommand switch(this->Makefile->GetPolicyStatus(cmPolicies::CMP0037)) { case cmPolicies::WARN: - if(type != cmTarget::INTERFACE_LIBRARY) + if(type != cmState::INTERFACE_LIBRARY) { e << cmPolicies::GetPolicyWarning(cmPolicies::CMP0037) << "\n"; issueMessage = true; @@ -293,12 +293,12 @@ bool cmAddLibraryCommand this->SetError(e.str()); return false; } - cmTarget::TargetType aliasedType = aliasedTarget->GetType(); - if(aliasedType != cmTarget::SHARED_LIBRARY - && aliasedType != cmTarget::STATIC_LIBRARY - && aliasedType != cmTarget::MODULE_LIBRARY - && aliasedType != cmTarget::OBJECT_LIBRARY - && aliasedType != cmTarget::INTERFACE_LIBRARY) + cmState::TargetType aliasedType = aliasedTarget->GetType(); + if(aliasedType != cmState::SHARED_LIBRARY + && aliasedType != cmState::STATIC_LIBRARY + && aliasedType != cmState::MODULE_LIBRARY + && aliasedType != cmState::OBJECT_LIBRARY + && aliasedType != cmState::INTERFACE_LIBRARY) { std::ostringstream e; e << "cannot create ALIAS target \"" << libName @@ -314,7 +314,7 @@ bool cmAddLibraryCommand this->SetError(e.str()); return false; } - this->Makefile->AddAlias(libName, aliasedTarget); + this->Makefile->AddAlias(libName, aliasedName); return true; } @@ -328,19 +328,19 @@ bool cmAddLibraryCommand CMAKE_${LANG}_CREATE_SHARED_LIBRARY is defined and if not default to STATIC. But at this point we know only the name of the target, but not yet its linker language. */ - if ((type == cmTarget::SHARED_LIBRARY || - type == cmTarget::MODULE_LIBRARY) && + if ((type == cmState::SHARED_LIBRARY || + type == cmState::MODULE_LIBRARY) && (this->Makefile->GetState()->GetGlobalPropertyAsBool( "TARGET_SUPPORTS_SHARED_LIBS") == false)) { std::ostringstream w; w << "ADD_LIBRARY called with " << - (type==cmTarget::SHARED_LIBRARY ? "SHARED" : "MODULE") << + (type==cmState::SHARED_LIBRARY ? "SHARED" : "MODULE") << " option but the target platform does not support dynamic linking. " "Building a STATIC library instead. This may lead to problems."; this->Makefile->IssueMessage(cmake::AUTHOR_WARNING, w.str()); - type = cmTarget::STATIC_LIBRARY; + type = cmState::STATIC_LIBRARY; } // Handle imported target creation. @@ -352,7 +352,7 @@ bool cmAddLibraryCommand this->SetError("called with IMPORTED argument but no library type."); return false; } - if(type == cmTarget::OBJECT_LIBRARY) + if(type == cmState::OBJECT_LIBRARY) { this->Makefile->IssueMessage( cmake::FATAL_ERROR, @@ -360,7 +360,7 @@ bool cmAddLibraryCommand ); return true; } - if(type == cmTarget::INTERFACE_LIBRARY) + if(type == cmState::INTERFACE_LIBRARY) { if (!cmGeneratorExpression::IsValidTargetName(libName)) { @@ -387,7 +387,7 @@ bool cmAddLibraryCommand } // A non-imported target may not have UNKNOWN type. - if(type == cmTarget::UNKNOWN_LIBRARY) + if(type == cmState::UNKNOWN_LIBRARY) { this->Makefile->IssueMessage( cmake::FATAL_ERROR, @@ -408,7 +408,7 @@ bool cmAddLibraryCommand std::vector<std::string> srclists; - if(type == cmTarget::INTERFACE_LIBRARY) + if(type == cmState::INTERFACE_LIBRARY) { if (!cmGeneratorExpression::IsValidTargetName(libName) || libName.find("::") != std::string::npos) diff --git a/Source/cmArchiveWrite.cxx b/Source/cmArchiveWrite.cxx index 7946950..e62a2ed 100644 --- a/Source/cmArchiveWrite.cxx +++ b/Source/cmArchiveWrite.cxx @@ -18,6 +18,10 @@ #include <cm_libarchive.h> #include "cm_get_date.h" +#ifndef __LA_SSIZE_T +# define __LA_SSIZE_T la_ssize_t +#endif + //---------------------------------------------------------------------------- static std::string cm_archive_error_string(struct archive* a) { diff --git a/Source/cmAuxSourceDirectoryCommand.cxx b/Source/cmAuxSourceDirectoryCommand.cxx index 5f5017d..92ac07d 100644 --- a/Source/cmAuxSourceDirectoryCommand.cxx +++ b/Source/cmAuxSourceDirectoryCommand.cxx @@ -60,10 +60,10 @@ bool cmAuxSourceDirectoryCommand::InitialPass std::string ext = file.substr(dotpos+1); std::string base = file.substr(0, dotpos); // Process only source files - if(!base.empty() - && std::find( this->Makefile->GetSourceExtensions().begin(), - this->Makefile->GetSourceExtensions().end(), ext ) - != this->Makefile->GetSourceExtensions().end() ) + std::vector<std::string> srcExts = + this->Makefile->GetCMakeInstance()->GetSourceExtensions(); + if(!base.empty() && + std::find(srcExts.begin(), srcExts.end(), ext) != srcExts.end()) { std::string fullname = templateDirectory; fullname += "/"; diff --git a/Source/cmBuildCommand.cxx b/Source/cmBuildCommand.cxx index 62fafa5..64d4fca 100644 --- a/Source/cmBuildCommand.cxx +++ b/Source/cmBuildCommand.cxx @@ -11,7 +11,6 @@ ============================================================================*/ #include "cmBuildCommand.h" -#include "cmLocalGenerator.h" #include "cmGlobalGenerator.h" //---------------------------------------------------------------------- diff --git a/Source/cmCPackPropertiesGenerator.cxx b/Source/cmCPackPropertiesGenerator.cxx index cbcdd81..35b3d59 100644 --- a/Source/cmCPackPropertiesGenerator.cxx +++ b/Source/cmCPackPropertiesGenerator.cxx @@ -18,7 +18,7 @@ void cmCPackPropertiesGenerator::GenerateScriptForConfig(std::ostream& os, const std::string& config, Indent const& indent) { std::string const& expandedFileName = - this->InstalledFile.GetNameExpression().Evaluate(this->LG->GetMakefile(), + this->InstalledFile.GetNameExpression().Evaluate(this->LG, config); cmInstalledFile::PropertyMapType const& properties = @@ -38,7 +38,7 @@ void cmCPackPropertiesGenerator::GenerateScriptForConfig(std::ostream& os, j = property.ValueExpressions.begin(); j != property.ValueExpressions.end(); ++j) { - std::string value = (*j)->Evaluate(LG->GetMakefile(), config); + std::string value = (*j)->Evaluate(this->LG, config); os << " " << cmOutputConverter::EscapeForCMake(value); } diff --git a/Source/cmCPluginAPI.cxx b/Source/cmCPluginAPI.cxx index 7da334e..fb78446 100644 --- a/Source/cmCPluginAPI.cxx +++ b/Source/cmCPluginAPI.cxx @@ -51,14 +51,14 @@ void CCONV cmSetError(void *info, const char *err) unsigned int CCONV cmGetCacheMajorVersion(void *arg) { cmMakefile *mf = static_cast<cmMakefile *>(arg); - cmCacheManager *manager = mf->GetCMakeInstance()->GetCacheManager(); - return manager->GetCacheMajorVersion(); + cmState *state = mf->GetState(); + return state->GetCacheMajorVersion(); } unsigned int CCONV cmGetCacheMinorVersion(void *arg) { cmMakefile *mf = static_cast<cmMakefile *>(arg); - cmCacheManager *manager = mf->GetCMakeInstance()->GetCacheManager(); - return manager->GetCacheMinorVersion(); + cmState *state = mf->GetState(); + return state->GetCacheMinorVersion(); } unsigned int CCONV cmGetMajorVersion(void *) @@ -116,7 +116,7 @@ const char* CCONV cmGetProjectName(void *arg) { cmMakefile *mf = static_cast<cmMakefile *>(arg); static std::string name; - name = mf->GetProjectName(); + name = mf->GetStateSnapshot().GetProjectName(); return name.c_str(); } @@ -373,13 +373,13 @@ void CCONV cmAddLinkLibraryForTarget(void *arg, const char *tgt, switch (libtype) { case CM_LIBRARY_GENERAL: - mf->AddLinkLibraryForTarget(tgt,value, cmTarget::GENERAL); + mf->AddLinkLibraryForTarget(tgt,value, GENERAL_LibraryType); break; case CM_LIBRARY_DEBUG: - mf->AddLinkLibraryForTarget(tgt,value, cmTarget::DEBUG); + mf->AddLinkLibraryForTarget(tgt,value, DEBUG_LibraryType); break; case CM_LIBRARY_OPTIMIZED: - mf->AddLinkLibraryForTarget(tgt,value, cmTarget::OPTIMIZED); + mf->AddLinkLibraryForTarget(tgt,value, OPTIMIZED_LibraryType); break; } } @@ -395,7 +395,7 @@ void CCONV cmAddLibrary(void *arg, const char *libname, int shared, srcs2.push_back(srcs[i]); } mf->AddLibrary(libname, - (shared? cmTarget::SHARED_LIBRARY : cmTarget::STATIC_LIBRARY), + (shared? cmState::SHARED_LIBRARY : cmState::STATIC_LIBRARY), srcs2); } diff --git a/Source/cmCTest.cxx b/Source/cmCTest.cxx index 6e55d89..f3e7121 100644 --- a/Source/cmCTest.cxx +++ b/Source/cmCTest.cxx @@ -14,7 +14,6 @@ #include "cmCTest.h" #include "cmake.h" #include "cmMakefile.h" -#include "cmLocalGenerator.h" #include "cmGlobalGenerator.h" #include <cmsys/Base64.h> #include <cmsys/Directory.hxx> @@ -518,9 +517,9 @@ int cmCTest::Initialize(const char* binary_dir, cmCTestStartCommand* command) cmake cm; cm.SetHomeDirectory(""); cm.SetHomeOutputDirectory(""); + cm.GetCurrentSnapshot().SetDefaultDefinitions(); cmGlobalGenerator gg(&cm); cmsys::auto_ptr<cmMakefile> mf(new cmMakefile(&gg, cm.GetCurrentSnapshot())); - cmsys::auto_ptr<cmLocalGenerator> lg(gg.CreateLocalGenerator(mf.get())); if ( !this->ReadCustomConfigurationFileTree(this->BinaryDir.c_str(), mf.get()) ) { diff --git a/Source/cmCacheManager.cxx b/Source/cmCacheManager.cxx index 54209c5..ce8af55 100644 --- a/Source/cmCacheManager.cxx +++ b/Source/cmCacheManager.cxx @@ -13,7 +13,6 @@ #include "cmCacheManager.h" #include "cmSystemTools.h" #include "cmGeneratedFileStream.h" -#include "cmMakefile.h" #include "cmake.h" #include "cmVersion.h" @@ -22,101 +21,10 @@ #include <cmsys/FStream.hxx> #include <cmsys/RegularExpression.hxx> -cmCacheManager::cmCacheManager(cmake* cm) +cmCacheManager::cmCacheManager() { this->CacheMajorVersion = 0; this->CacheMinorVersion = 0; - this->CMakeInstance = cm; -} - -bool cmCacheManager::LoadCache(const std::string& path) -{ - std::set<std::string> emptySet; - return this->LoadCache(path, true, emptySet, emptySet); -} - -static bool ParseEntryWithoutType(const std::string& entry, - std::string& var, - std::string& value) -{ - // input line is: key=value - static cmsys::RegularExpression reg( - "^([^=]*)=(.*[^\r\t ]|[\r\t ]*)[\r\t ]*$"); - // input line is: "key"=value - static cmsys::RegularExpression regQuoted( - "^\"([^\"]*)\"=(.*[^\r\t ]|[\r\t ]*)[\r\t ]*$"); - bool flag = false; - if(regQuoted.find(entry)) - { - var = regQuoted.match(1); - value = regQuoted.match(2); - flag = true; - } - else if (reg.find(entry)) - { - var = reg.match(1); - value = reg.match(2); - flag = true; - } - - // if value is enclosed in single quotes ('foo') then remove them - // it is used to enclose trailing space or tab - if (flag && - value.size() >= 2 && - value[0] == '\'' && - value[value.size() - 1] == '\'') - { - value = value.substr(1, - value.size() - 2); - } - - return flag; -} - -bool cmCacheManager::ParseEntry(const std::string& entry, - std::string& var, - std::string& value, - cmState::CacheEntryType& type) -{ - // input line is: key:type=value - static cmsys::RegularExpression reg( - "^([^=:]*):([^=]*)=(.*[^\r\t ]|[\r\t ]*)[\r\t ]*$"); - // input line is: "key":type=value - static cmsys::RegularExpression regQuoted( - "^\"([^\"]*)\":([^=]*)=(.*[^\r\t ]|[\r\t ]*)[\r\t ]*$"); - bool flag = false; - if(regQuoted.find(entry)) - { - var = regQuoted.match(1); - type = cmState::StringToCacheEntryType(regQuoted.match(2).c_str()); - value = regQuoted.match(3); - flag = true; - } - else if (reg.find(entry)) - { - var = reg.match(1); - type = cmState::StringToCacheEntryType(reg.match(2).c_str()); - value = reg.match(3); - flag = true; - } - - // if value is enclosed in single quotes ('foo') then remove them - // it is used to enclose trailing space or tab - if (flag && - value.size() >= 2 && - value[0] == '\'' && - value[value.size() - 1] == '\'') - { - value = value.substr(1, - value.size() - 2); - } - - if (!flag) - { - return ParseEntryWithoutType(entry, var, value); - } - - return flag; } void cmCacheManager::CleanCMakeFiles(const std::string& path) @@ -195,7 +103,7 @@ bool cmCacheManager::LoadCache(const std::string& path, } } e.SetProperty("HELPSTRING", helpString.c_str()); - if(cmCacheManager::ParseEntry(realbuffer, entryKey, e.Value, e.Type)) + if(cmState::ParseCacheEntry(realbuffer, entryKey, e.Value, e.Type)) { if ( excludes.find(entryKey) == excludes.end() ) { @@ -678,7 +586,6 @@ void cmCacheManager::AddCacheEntry(const std::string& key, } e.SetProperty("HELPSTRING", helpString? helpString : "(This variable does not exist and should not be used)"); - this->CMakeInstance->UnwatchUnusedCli(key); } bool cmCacheManager::CacheIterator::IsAtEnd() const diff --git a/Source/cmCacheManager.h b/Source/cmCacheManager.h index 8462259..6f063eb 100644 --- a/Source/cmCacheManager.h +++ b/Source/cmCacheManager.h @@ -16,9 +16,7 @@ #include "cmPropertyMap.h" #include "cmState.h" -class cmMakefile; class cmMarkAsAdvancedCommand; -class cmake; /** \class cmCacheManager * \brief Control class for cmake's cache @@ -29,7 +27,7 @@ class cmake; class cmCacheManager { public: - cmCacheManager(cmake* cm); + cmCacheManager(); class CacheIterator; friend class cmCacheManager::CacheIterator; @@ -100,7 +98,6 @@ public: } ///! Load a cache for given makefile. Loads from path/CMakeCache.txt. - bool LoadCache(const std::string& path); bool LoadCache(const std::string& path, bool internal, std::set<std::string>& excludes, std::set<std::string>& includes); @@ -124,12 +121,6 @@ public: int GetSize() { return static_cast<int>(this->Cache.size()); } - ///! Break up a line like VAR:type="value" into var, type and value - static bool ParseEntry(const std::string& entry, - std::string& var, - std::string& value, - cmState::CacheEntryType& type); - ///! Get a value from the cache given a key const char* GetInitializedCacheValue(const std::string& key) const; @@ -241,7 +232,7 @@ private: void WritePropertyEntries(std::ostream& os, CacheIterator const& i); CacheEntryMap Cache; - // Only cmake and cmMakefile should be able to add cache values + // Only cmake and cmState should be able to add cache values // the commands should never use the cmCacheManager directly friend class cmState; // allow access to add cache values friend class cmake; // allow access to add cache values diff --git a/Source/cmCommonTargetGenerator.cxx b/Source/cmCommonTargetGenerator.cxx index 252e231..76ed038 100644 --- a/Source/cmCommonTargetGenerator.cxx +++ b/Source/cmCommonTargetGenerator.cxx @@ -18,7 +18,6 @@ #include "cmMakefile.h" #include "cmSourceFile.h" #include "cmSystemTools.h" -#include "cmTarget.h" cmCommonTargetGenerator::cmCommonTargetGenerator( cmOutputConverter::RelativeRoot wd, @@ -26,7 +25,6 @@ cmCommonTargetGenerator::cmCommonTargetGenerator( ) : WorkingDirectory(wd) , GeneratorTarget(gt) - , Target(gt->Target) , Makefile(gt->Makefile) , LocalGenerator(static_cast<cmLocalCommonGenerator*>(gt->LocalGenerator)) , GlobalGenerator(static_cast<cmGlobalCommonGenerator*>( @@ -83,7 +81,7 @@ void cmCommonTargetGenerator::AddFeatureFlags( //---------------------------------------------------------------------------- void cmCommonTargetGenerator::AddModuleDefinitionFlag(std::string& flags) { - if(this->ModuleDefinitionFile.empty()) + if(!this->ModuleDefinitionFile) { return; } @@ -100,7 +98,7 @@ void cmCommonTargetGenerator::AddModuleDefinitionFlag(std::string& flags) // vs6's "cl -link" pass it to the linker. std::string flag = defFileFlag; flag += (this->LocalGenerator->ConvertToLinkReference( - this->ModuleDefinitionFile)); + this->ModuleDefinitionFile->GetFullPath())); this->LocalGenerator->AppendFlags(flags, flag); } @@ -109,7 +107,7 @@ std::string cmCommonTargetGenerator::ComputeFortranModuleDirectory() const { std::string mod_dir; const char* target_mod_dir = - this->Target->GetProperty("Fortran_MODULE_DIRECTORY"); + this->GeneratorTarget->GetProperty("Fortran_MODULE_DIRECTORY"); const char* moddir_flag = this->Makefile->GetDefinition("CMAKE_Fortran_MODDIR_FLAG"); if(target_mod_dir && moddir_flag) @@ -123,7 +121,7 @@ std::string cmCommonTargetGenerator::ComputeFortranModuleDirectory() const else { // Interpret relative to the current output directory. - mod_dir = this->Makefile->GetCurrentBinaryDirectory(); + mod_dir = this->LocalGenerator->GetCurrentBinaryDirectory(); mod_dir += "/"; mod_dir += target_mod_dir; } @@ -214,7 +212,7 @@ cmCommonTargetGenerator this->LocalGenerator->GetFortranFormat(srcfmt); if(format == cmLocalGenerator::FortranFormatNone) { - const char* tgtfmt = this->Target->GetProperty("Fortran_FORMAT"); + const char* tgtfmt = this->GeneratorTarget->GetProperty("Fortran_FORMAT"); format = this->LocalGenerator->GetFortranFormat(tgtfmt); } const char* var = 0; @@ -265,7 +263,7 @@ std::string cmCommonTargetGenerator::GetFrameworkFlags(std::string const& l) for(std::vector<std::string>::iterator i = includes.begin(); i != includes.end(); ++i) { - if(this->Target->NameResolvesToFramework(*i)) + if(this->GlobalGenerator->NameResolvesToFramework(*i)) { std::string frameworkDir = *i; frameworkDir += "/../"; @@ -316,10 +314,11 @@ std::string cmCommonTargetGenerator::GetFlags(const std::string &l) this->AddFortranFlags(flags); } - this->LocalGenerator->AddCMP0018Flags(flags, this->Target, + this->LocalGenerator->AddCMP0018Flags(flags, this->GeneratorTarget, lang, this->ConfigName); - this->LocalGenerator->AddVisibilityPresetFlags(flags, this->Target, + this->LocalGenerator->AddVisibilityPresetFlags(flags, + this->GeneratorTarget, lang); // Append old-style preprocessor definition flags. @@ -331,7 +330,7 @@ std::string cmCommonTargetGenerator::GetFlags(const std::string &l) AppendFlags(flags,this->GetFrameworkFlags(l)); // Add target-specific flags. - this->LocalGenerator->AddCompileOptions(flags, this->Target, + this->LocalGenerator->AddCompileOptions(flags, this->GeneratorTarget, lang, this->ConfigName); ByLanguageMap::value_type entry(l, flags); @@ -348,13 +347,14 @@ std::string cmCommonTargetGenerator::GetDefines(const std::string &l) std::set<std::string> defines; const char *lang = l.c_str(); // Add the export symbol definition for shared library objects. - if(const char* exportMacro = this->Target->GetExportMacro()) + if(const char* exportMacro = + this->GeneratorTarget->GetExportMacro()) { this->LocalGenerator->AppendDefines(defines, exportMacro); } // Add preprocessor definitions for this target and configuration. - this->LocalGenerator->AddCompileDefinitions(defines, this->Target, + this->LocalGenerator->AddCompileDefinitions(defines, this->GeneratorTarget, this->LocalGenerator->GetConfigName(), l); std::string definesString; @@ -383,7 +383,7 @@ std::vector<std::string> cmCommonTargetGenerator::GetLinkedTargetDirectories() const { std::vector<std::string> dirs; - std::set<cmTarget const*> emitted; + std::set<cmGeneratorTarget const*> emitted; if (cmComputeLinkInformation* cli = this->GeneratorTarget->GetLinkInformation(this->ConfigName)) { @@ -391,21 +391,18 @@ cmCommonTargetGenerator::GetLinkedTargetDirectories() const for(cmComputeLinkInformation::ItemVector::const_iterator i = items.begin(); i != items.end(); ++i) { - cmTarget const* linkee = i->Target; + cmGeneratorTarget const* linkee = i->Target; if(linkee && !linkee->IsImported() // We can ignore the INTERFACE_LIBRARY items because // Target->GetLinkInformation already processed their // link interface and they don't have any output themselves. - && linkee->GetType() != cmTarget::INTERFACE_LIBRARY + && linkee->GetType() != cmState::INTERFACE_LIBRARY && emitted.insert(linkee).second) { - cmGeneratorTarget* gt = - this->GlobalGenerator->GetGeneratorTarget(linkee); - cmLocalGenerator* lg = gt->GetLocalGenerator(); - cmMakefile* mf = linkee->GetMakefile(); - std::string di = mf->GetCurrentBinaryDirectory(); + cmLocalGenerator* lg = linkee->GetLocalGenerator(); + std::string di = lg->GetCurrentBinaryDirectory(); di += "/"; - di += lg->GetTargetDirectory(*linkee); + di += lg->GetTargetDirectory(linkee); dirs.push_back(di); } } diff --git a/Source/cmCommonTargetGenerator.h b/Source/cmCommonTargetGenerator.h index a4b2c10..0c17500 100644 --- a/Source/cmCommonTargetGenerator.h +++ b/Source/cmCommonTargetGenerator.h @@ -21,7 +21,6 @@ class cmGlobalCommonGenerator; class cmLocalCommonGenerator; class cmMakefile; class cmSourceFile; -class cmTarget; /** \class cmCommonTargetGenerator * \brief Common infrastructure for Makefile and Ninja per-target generators @@ -49,14 +48,13 @@ protected: cmOutputConverter::RelativeRoot WorkingDirectory; cmGeneratorTarget* GeneratorTarget; - cmTarget* Target; cmMakefile* Makefile; cmLocalCommonGenerator* LocalGenerator; cmGlobalCommonGenerator* GlobalGenerator; std::string ConfigName; // The windows module definition source file (.def), if any. - std::string ModuleDefinitionFile; + cmSourceFile const* ModuleDefinitionFile; // Target-wide Fortran module output directory. bool FortranModuleDirectoryComputed; diff --git a/Source/cmComputeLinkDepends.cxx b/Source/cmComputeLinkDepends.cxx index 1b5c9f4..13098ad 100644 --- a/Source/cmComputeLinkDepends.cxx +++ b/Source/cmComputeLinkDepends.cxx @@ -185,7 +185,9 @@ cmComputeLinkDepends // The configuration being linked. this->HasConfig = !config.empty(); this->Config = (this->HasConfig)? config : std::string(); - this->LinkType = this->Target->Target->ComputeLinkType(this->Config); + std::vector<std::string> debugConfigs = + this->Makefile->GetCMakeInstance()->GetDebugConfigs(); + this->LinkType = CMP0003_ComputeLinkType(this->Config, debugConfigs); // Enable debug mode if requested. this->DebugMode = this->Makefile->IsOn("CMAKE_LINK_DEPENDS_DEBUG_MODE"); @@ -268,9 +270,9 @@ cmComputeLinkDepends::Compute() { int i = *li; LinkEntry const& e = this->EntryList[i]; - cmTarget const* t = e.Target; + cmGeneratorTarget const* t = e.Target; // Entries that we know the linker will re-use do not need to be repeated. - bool uniquify = t && t->GetType() == cmTarget::SHARED_LIBRARY; + bool uniquify = t && t->GetType() == cmState::SHARED_LIBRARY; if(!uniquify || emmitted.insert(i).second) { this->FinalLinkEntries.push_back(e); @@ -362,14 +364,12 @@ void cmComputeLinkDepends::FollowLinkEntry(BFSEntry const& qe) // Follow the item's dependencies. if(entry.Target) { - cmGeneratorTarget* gtgt = - this->GlobalGenerator->GetGeneratorTarget(entry.Target); // Follow the target dependencies. if(cmLinkInterface const* iface = - gtgt->GetLinkInterface(this->Config, this->Target->Target)) + entry.Target->GetLinkInterface(this->Config, this->Target)) { const bool isIface = - entry.Target->GetType() == cmTarget::INTERFACE_LIBRARY; + entry.Target->GetType() == cmState::INTERFACE_LIBRARY; // This target provides its own link interface information. this->AddLinkEntries(depender_index, iface->Libraries); @@ -463,10 +463,8 @@ void cmComputeLinkDepends::HandleSharedDependency(SharedDepEntry const& dep) // Target items may have their own dependencies. if(entry.Target) { - cmGeneratorTarget* gtgt = - this->GlobalGenerator->GetGeneratorTarget(entry.Target); if(cmLinkInterface const* iface = - gtgt->GetLinkInterface(this->Config, this->Target->Target)) + entry.Target->GetLinkInterface(this->Config, this->Target)) { // Follow public and private dependencies transitively. this->FollowSharedDeps(index, iface, true); @@ -486,24 +484,24 @@ void cmComputeLinkDepends::AddVarLinkEntries(int depender_index, // Look for entries meant for this configuration. std::vector<cmLinkItem> actual_libs; - cmTarget::LinkLibraryType llt = cmTarget::GENERAL; + cmTargetLinkLibraryType llt = GENERAL_LibraryType; bool haveLLT = false; for(std::vector<std::string>::const_iterator di = deplist.begin(); di != deplist.end(); ++di) { if(*di == "debug") { - llt = cmTarget::DEBUG; + llt = DEBUG_LibraryType; haveLLT = true; } else if(*di == "optimized") { - llt = cmTarget::OPTIMIZED; + llt = OPTIMIZED_LibraryType; haveLLT = true; } else if(*di == "general") { - llt = cmTarget::GENERAL; + llt = GENERAL_LibraryType; haveLLT = true; } else if(!di->empty()) @@ -521,17 +519,17 @@ void cmComputeLinkDepends::AddVarLinkEntries(int depender_index, { if(strcmp(val, "debug") == 0) { - llt = cmTarget::DEBUG; + llt = DEBUG_LibraryType; } else if(strcmp(val, "optimized") == 0) { - llt = cmTarget::OPTIMIZED; + llt = OPTIMIZED_LibraryType; } } } // If the library is meant for this link type then use it. - if(llt == cmTarget::GENERAL || llt == this->LinkType) + if(llt == GENERAL_LibraryType || llt == this->LinkType) { cmLinkItem item(*di, this->FindTargetToLink(depender_index, *di)); actual_libs.push_back(item); @@ -543,7 +541,7 @@ void cmComputeLinkDepends::AddVarLinkEntries(int depender_index, } // Reset the link type until another explicit type is given. - llt = cmTarget::GENERAL; + llt = GENERAL_LibraryType; haveLLT = false; } } @@ -635,14 +633,16 @@ cmComputeLinkDepends::AddLinkEntries( } //---------------------------------------------------------------------------- -cmTarget const* cmComputeLinkDepends::FindTargetToLink(int depender_index, - const std::string& name) +cmGeneratorTarget const* +cmComputeLinkDepends::FindTargetToLink(int depender_index, + const std::string& name) { // Look for a target in the scope of the depender. - cmTarget const* from = this->Target->Target; + cmGeneratorTarget const* from = this->Target; if(depender_index >= 0) { - if(cmTarget const* depender = this->EntryList[depender_index].Target) + if(cmGeneratorTarget const* depender = + this->EntryList[depender_index].Target) { from = depender; } @@ -934,12 +934,10 @@ int cmComputeLinkDepends::ComputeComponentCount(NodeList const& nl) int count = 2; for(NodeList::const_iterator ni = nl.begin(); ni != nl.end(); ++ni) { - if(cmTarget const* target = this->EntryList[*ni].Target) + if(cmGeneratorTarget const* target = this->EntryList[*ni].Target) { - cmGeneratorTarget* gtgt = - this->GlobalGenerator->GetGeneratorTarget(target); if(cmLinkInterface const* iface = - gtgt->GetLinkInterface(this->Config, this->Target->Target)) + target->GetLinkInterface(this->Config, this->Target)) { if(iface->Multiplicity > count) { diff --git a/Source/cmComputeLinkDepends.h b/Source/cmComputeLinkDepends.h index 2cbb430..f10e4e4 100644 --- a/Source/cmComputeLinkDepends.h +++ b/Source/cmComputeLinkDepends.h @@ -13,7 +13,7 @@ #define cmComputeLinkDepends_h #include "cmStandardIncludes.h" -#include "cmTarget.h" +#include "cmLinkItem.h" #include "cmGraphAdjacencyList.h" @@ -23,7 +23,6 @@ class cmComputeComponentGraph; class cmGlobalGenerator; class cmMakefile; class cmGeneratorTarget; -class cmTarget; class cmake; /** \class cmComputeLinkDepends @@ -40,7 +39,7 @@ public: struct LinkEntry { std::string Item; - cmTarget const* Target; + cmGeneratorTarget const* Target; bool IsSharedDep; bool IsFlag; LinkEntry(): Item(), Target(0), IsSharedDep(false), IsFlag(false) {} @@ -53,7 +52,7 @@ public: EntryVector const& Compute(); void SetOldLinkDirMode(bool b); - std::set<cmTarget const*> const& GetOldWrongConfigItems() const + std::set<cmGeneratorTarget const*> const& GetOldWrongConfigItems() const { return this->OldWrongConfigItems; } private: @@ -66,8 +65,6 @@ private: std::string Config; EntryVector FinalLinkEntries; - typedef cmTarget::LinkLibraryVectorType LinkLibraryVectorType; - std::map<std::string, int>::iterator AllocateLinkEntry(std::string const& item); int AddLinkEntry(cmLinkItem const& item); @@ -75,8 +72,8 @@ private: void AddDirectLinkEntries(); template <typename T> void AddLinkEntries(int depender_index, std::vector<T> const& libs); - cmTarget const* FindTargetToLink(int depender_index, - const std::string& name); + cmGeneratorTarget const* FindTargetToLink(int depender_index, + const std::string& name); // One entry for each unique item. std::vector<LinkEntry> EntryList; @@ -153,11 +150,11 @@ private: // Record of the original link line. std::vector<int> OriginalEntries; - std::set<cmTarget const*> OldWrongConfigItems; + std::set<cmGeneratorTarget const*> OldWrongConfigItems; void CheckWrongConfigItem(cmLinkItem const& item); int ComponentOrderId; - cmTarget::LinkLibraryType LinkType; + cmTargetLinkLibraryType LinkType; bool HasConfig; bool DebugMode; bool OldLinkDirMode; diff --git a/Source/cmComputeLinkInformation.cxx b/Source/cmComputeLinkInformation.cxx index d35b566..50d8324 100644 --- a/Source/cmComputeLinkInformation.cxx +++ b/Source/cmComputeLinkInformation.cxx @@ -19,7 +19,6 @@ #include "cmState.h" #include "cmOutputConverter.h" #include "cmMakefile.h" -#include "cmTarget.h" #include "cmGeneratorTarget.h" #include "cmake.h" #include "cmAlgorithms.h" @@ -284,14 +283,14 @@ cmComputeLinkInformation // Check whether we should skip dependencies on shared library files. this->LinkDependsNoShared = - this->Target->Target->GetPropertyAsBool("LINK_DEPENDS_NO_SHARED"); + this->Target->GetPropertyAsBool("LINK_DEPENDS_NO_SHARED"); // On platforms without import libraries there may be a special flag // to use when creating a plugin (module) that obtains symbols from // the program that will load it. this->LoaderFlag = 0; if(!this->UseImportLibrary && - this->Target->Target->GetType() == cmTarget::MODULE_LIBRARY) + this->Target->GetType() == cmState::MODULE_LIBRARY) { std::string loader_flag_var = "CMAKE_SHARED_MODULE_LOADER_"; loader_flag_var += this->LinkLanguage; @@ -309,10 +308,10 @@ cmComputeLinkInformation // Get options needed to specify RPATHs. this->RuntimeUseChrpath = false; - if(this->Target->Target->GetType() != cmTarget::STATIC_LIBRARY) + if(this->Target->GetType() != cmState::STATIC_LIBRARY) { const char* tType = - ((this->Target->Target->GetType() == cmTarget::EXECUTABLE)? + ((this->Target->GetType() == cmState::EXECUTABLE)? "EXECUTABLE" : "SHARED_LIBRARY"); std::string rtVar = "CMAKE_"; rtVar += tType; @@ -378,9 +377,9 @@ cmComputeLinkInformation // Add the search path entries requested by the user to path ordering. this->OrderLinkerSearchPath - ->AddUserDirectories(this->Target->Target->GetLinkDirectories()); + ->AddUserDirectories(this->Target->GetLinkDirectories()); this->OrderRuntimeSearchPath - ->AddUserDirectories(this->Target->Target->GetLinkDirectories()); + ->AddUserDirectories(this->Target->GetLinkDirectories()); // Set up the implicit link directories. this->LoadImplicitLinkInfo(); @@ -408,13 +407,13 @@ cmComputeLinkInformation // order to support such projects we need to add the directories // containing libraries linked with a full path to the -L path. this->OldLinkDirMode = - this->Target->Target->GetPolicyStatusCMP0003() != cmPolicies::NEW; + this->Target->GetPolicyStatusCMP0003() != cmPolicies::NEW; if(this->OldLinkDirMode) { // Construct a mask to not bother with this behavior for link // directories already specified by the user. std::vector<std::string> const& dirs = - this->Target->Target->GetLinkDirectories(); + this->Target->GetLinkDirectories(); this->OldLinkDirMask.insert(dirs.begin(), dirs.end()); } @@ -471,7 +470,7 @@ std::vector<std::string> const& cmComputeLinkInformation::GetFrameworkPaths() } //---------------------------------------------------------------------------- -std::set<cmTarget const*> const& +const std::set<const cmGeneratorTarget*>& cmComputeLinkInformation::GetSharedLibrariesLinked() { return this->SharedLibrariesLinked; @@ -481,10 +480,10 @@ cmComputeLinkInformation::GetSharedLibrariesLinked() bool cmComputeLinkInformation::Compute() { // Skip targets that do not link. - if(!(this->Target->GetType() == cmTarget::EXECUTABLE || - this->Target->GetType() == cmTarget::SHARED_LIBRARY || - this->Target->GetType() == cmTarget::MODULE_LIBRARY || - this->Target->GetType() == cmTarget::STATIC_LIBRARY)) + if(!(this->Target->GetType() == cmState::EXECUTABLE || + this->Target->GetType() == cmState::SHARED_LIBRARY || + this->Target->GetType() == cmState::MODULE_LIBRARY || + this->Target->GetType() == cmState::STATIC_LIBRARY)) { return false; } @@ -521,7 +520,7 @@ bool cmComputeLinkInformation::Compute() // Restore the target link type so the correct system runtime // libraries are found. const char* lss = - this->Target->Target->GetProperty("LINK_SEARCH_END_STATIC"); + this->Target->GetProperty("LINK_SEARCH_END_STATIC"); if(cmSystemTools::IsOn(lss)) { this->SetCurrentLinkType(LinkStatic); @@ -537,16 +536,16 @@ bool cmComputeLinkInformation::Compute() // For CMake 2.4 bug-compatibility we need to consider the output // directories of targets linked in another configuration as link // directories. - std::set<cmTarget const*> const& wrongItems = cld.GetOldWrongConfigItems(); - for(std::set<cmTarget const*>::const_iterator i = wrongItems.begin(); - i != wrongItems.end(); ++i) + std::set<cmGeneratorTarget const*> const& wrongItems = + cld.GetOldWrongConfigItems(); + for(std::set<cmGeneratorTarget const*>::const_iterator i = + wrongItems.begin(); i != wrongItems.end(); ++i) { - cmTarget const* tgt = *i; - cmGeneratorTarget *gtgt = this->GlobalGenerator->GetGeneratorTarget(tgt); + cmGeneratorTarget const* tgt = *i; bool implib = (this->UseImportLibrary && - (tgt->GetType() == cmTarget::SHARED_LIBRARY)); - std::string lib = gtgt->GetFullPath(this->Config , implib, true); + (tgt->GetType() == cmState::SHARED_LIBRARY)); + std::string lib = tgt->GetFullPath(this->Config , implib, true); this->OldLinkDirItems.push_back(lib); } } @@ -572,7 +571,7 @@ bool cmComputeLinkInformation::Compute() "name." ; this->CMakeInstance->IssueMessage(cmake::AUTHOR_WARNING, w.str(), - this->Target->Target->GetBacktrace()); + this->Target->GetBacktrace()); } return true; @@ -632,7 +631,7 @@ void cmComputeLinkInformation::AddImplicitLinkInfo(std::string const& lang) //---------------------------------------------------------------------------- void cmComputeLinkInformation::AddItem(std::string const& item, - cmTarget const* tgt) + cmGeneratorTarget const* tgt) { // Compute the proper name to use to link this library. const std::string& config = this->Config; @@ -646,7 +645,6 @@ void cmComputeLinkInformation::AddItem(std::string const& item, if(tgt && tgt->IsLinkable()) { - cmGeneratorTarget *gtgt = this->GlobalGenerator->GetGeneratorTarget(tgt); // This is a CMake target. Ask the target for its real name. if(impexe && this->LoaderFlag) { @@ -656,13 +654,13 @@ void cmComputeLinkInformation::AddItem(std::string const& item, std::string linkItem; linkItem = this->LoaderFlag; - std::string exe = gtgt->GetFullPath(config, this->UseImportLibrary, + std::string exe = tgt->GetFullPath(config, this->UseImportLibrary, true); linkItem += exe; this->Items.push_back(Item(linkItem, true, tgt)); this->Depends.push_back(exe); } - else if(tgt->GetType() == cmTarget::INTERFACE_LIBRARY) + else if(tgt->GetType() == cmState::INTERFACE_LIBRARY) { // Add the interface library as an item so it can be considered as part // of COMPATIBLE_INTERFACE_ enforcement. The generators will ignore @@ -674,12 +672,12 @@ void cmComputeLinkInformation::AddItem(std::string const& item, // Decide whether to use an import library. bool implib = (this->UseImportLibrary && - (impexe || tgt->GetType() == cmTarget::SHARED_LIBRARY)); + (impexe || tgt->GetType() == cmState::SHARED_LIBRARY)); // Pass the full path to the target file. - std::string lib = gtgt->GetFullPath(config, implib, true); + std::string lib = tgt->GetFullPath(config, implib, true); if(!this->LinkDependsNoShared || - tgt->GetType() != cmTarget::SHARED_LIBRARY) + tgt->GetType() != cmState::SHARED_LIBRARY) { this->Depends.push_back(lib); } @@ -716,7 +714,7 @@ void cmComputeLinkInformation::AddItem(std::string const& item, //---------------------------------------------------------------------------- void cmComputeLinkInformation::AddSharedDepItem(std::string const& item, - cmTarget const* tgt) + const cmGeneratorTarget* tgt) { // If dropping shared library dependencies, ignore them. if(this->SharedDependencyMode == SharedDepModeNone) @@ -730,7 +728,7 @@ void cmComputeLinkInformation::AddSharedDepItem(std::string const& item, { // The target will provide a full path. Make sure it is a shared // library. - if(tgt->GetType() != cmTarget::SHARED_LIBRARY) + if(tgt->GetType() != cmState::SHARED_LIBRARY) { return; } @@ -760,17 +758,13 @@ void cmComputeLinkInformation::AddSharedDepItem(std::string const& item, return; } - cmGeneratorTarget *gtgt = 0; - // Get a full path to the dependent shared library. // Add it to the runtime path computation so that the target being // linked will be able to find it. std::string lib; if(tgt) { - gtgt = this->GlobalGenerator->GetGeneratorTarget(tgt); - - lib = gtgt->GetFullPath(this->Config, this->UseImportLibrary); + lib = tgt->GetFullPath(this->Config, this->UseImportLibrary); this->AddLibraryRuntimeInfo(lib, tgt); } else @@ -795,9 +789,9 @@ void cmComputeLinkInformation::AddSharedDepItem(std::string const& item, } if(order) { - if(gtgt) + if(tgt) { - std::string soName = gtgt->GetSOName(this->Config); + std::string soName = tgt->GetSOName(this->Config); const char* soname = soName.empty()? 0 : soName.c_str(); order->AddRuntimeLibrary(lib, soname); } @@ -824,9 +818,9 @@ void cmComputeLinkInformation::ComputeLinkTypeInfo() const char* target_type_str = 0; switch(this->Target->GetType()) { - case cmTarget::EXECUTABLE: target_type_str = "EXE"; break; - case cmTarget::SHARED_LIBRARY: target_type_str = "SHARED_LIBRARY"; break; - case cmTarget::MODULE_LIBRARY: target_type_str = "SHARED_MODULE"; break; + case cmState::EXECUTABLE: target_type_str = "EXE"; break; + case cmState::SHARED_LIBRARY: target_type_str = "SHARED_LIBRARY"; break; + case cmState::MODULE_LIBRARY: target_type_str = "SHARED_MODULE"; break; default: break; } if(target_type_str) @@ -860,7 +854,7 @@ void cmComputeLinkInformation::ComputeLinkTypeInfo() // Lookup the starting link type from the target (linked statically?). const char* lss = - this->Target->Target->GetProperty("LINK_SEARCH_START_STATIC"); + this->Target->GetProperty("LINK_SEARCH_START_STATIC"); this->StartLinkType = cmSystemTools::IsOn(lss)? LinkStatic : LinkShared; this->CurrentLinkType = this->StartLinkType; } @@ -1082,7 +1076,7 @@ void cmComputeLinkInformation::SetCurrentLinkType(LinkType lt) //---------------------------------------------------------------------------- void cmComputeLinkInformation::AddTargetItem(std::string const& item, - cmTarget const* target) + cmGeneratorTarget const* target) { // This is called to handle a link item that is a full path to a target. // If the target is not a static library make sure the link type is @@ -1090,13 +1084,13 @@ void cmComputeLinkInformation::AddTargetItem(std::string const& item, // shared and static libraries but static-mode can handle only // static libraries. If a previous user item changed the link type // to static we need to make sure it is back to shared. - if(target->GetType() != cmTarget::STATIC_LIBRARY) + if(target->GetType() != cmState::STATIC_LIBRARY) { this->SetCurrentLinkType(LinkShared); } // Keep track of shared library targets linked. - if(target->GetType() == cmTarget::SHARED_LIBRARY) + if(target->GetType() == cmState::SHARED_LIBRARY) { this->SharedLibrariesLinked.insert(target); } @@ -1146,7 +1140,7 @@ void cmComputeLinkInformation::AddFullItem(std::string const& item) // Full path libraries should specify a valid library file name. // See documentation of CMP0008. std::string generator = this->GlobalGenerator->GetName(); - if(this->Target->Target->GetPolicyStatusCMP0008() != cmPolicies::NEW && + if(this->Target->GetPolicyStatusCMP0008() != cmPolicies::NEW && (generator.find("Visual Studio") != generator.npos || generator.find("Xcode") != generator.npos)) { @@ -1227,7 +1221,7 @@ bool cmComputeLinkInformation::CheckImplicitDirItem(std::string const& item) } // Check the policy for whether we should use the approach below. - switch (this->Target->Target->GetPolicyStatusCMP0060()) + switch (this->Target->GetPolicyStatusCMP0060()) { case cmPolicies::WARN: if (this->CMP0060Warn) @@ -1537,7 +1531,7 @@ void cmComputeLinkInformation::HandleBadFullItem(std::string const& item, this->OrderLinkerSearchPath->AddLinkLibrary(item); // Produce any needed message. - switch(this->Target->Target->GetPolicyStatusCMP0008()) + switch(this->Target->GetPolicyStatusCMP0008()) { case cmPolicies::WARN: { @@ -1554,7 +1548,7 @@ void cmComputeLinkInformation::HandleBadFullItem(std::string const& item, << " " << item << "\n" << "which is a full-path but not a valid library file name."; this->CMakeInstance->IssueMessage(cmake::AUTHOR_WARNING, w.str(), - this->Target->Target->GetBacktrace()); + this->Target->GetBacktrace()); } } case cmPolicies::OLD: @@ -1572,7 +1566,7 @@ void cmComputeLinkInformation::HandleBadFullItem(std::string const& item, << " " << item << "\n" << "which is a full-path but not a valid library file name."; this->CMakeInstance->IssueMessage(cmake::FATAL_ERROR, e.str(), - this->Target->Target->GetBacktrace()); + this->Target->GetBacktrace()); } break; } @@ -1589,7 +1583,7 @@ bool cmComputeLinkInformation::FinishLinkerSearchDirectories() } // Enforce policy constraints. - switch(this->Target->Target->GetPolicyStatusCMP0003()) + switch(this->Target->GetPolicyStatusCMP0003()) { case cmPolicies::WARN: if(!this->CMakeInstance->GetState() @@ -1600,7 +1594,7 @@ bool cmComputeLinkInformation::FinishLinkerSearchDirectories() std::ostringstream w; this->PrintLinkPolicyDiagnosis(w); this->CMakeInstance->IssueMessage(cmake::AUTHOR_WARNING, w.str(), - this->Target->Target->GetBacktrace()); + this->Target->GetBacktrace()); } case cmPolicies::OLD: // OLD behavior is to add the paths containing libraries with @@ -1616,7 +1610,7 @@ bool cmComputeLinkInformation::FinishLinkerSearchDirectories() e << cmPolicies::GetRequiredPolicyError(cmPolicies::CMP0003) << "\n"; this->PrintLinkPolicyDiagnosis(e); this->CMakeInstance->IssueMessage(cmake::FATAL_ERROR, e.str(), - this->Target->Target->GetBacktrace()); + this->Target->GetBacktrace()); return false; } } @@ -1781,7 +1775,7 @@ cmComputeLinkInformation::GetRuntimeSearchPath() //---------------------------------------------------------------------------- void cmComputeLinkInformation::AddLibraryRuntimeInfo(std::string const& fullPath, - cmTarget const* target) + cmGeneratorTarget const* target) { // Ignore targets on Apple where install_name is not @rpath. // The dependenty library can be found with other means such as @@ -1796,22 +1790,21 @@ cmComputeLinkInformation::AddLibraryRuntimeInfo(std::string const& fullPath, // Libraries with unknown type must be handled using just the file // on disk. - if(target->GetType() == cmTarget::UNKNOWN_LIBRARY) + if(target->GetType() == cmState::UNKNOWN_LIBRARY) { this->AddLibraryRuntimeInfo(fullPath); return; } // Skip targets that are not shared libraries (modules cannot be linked). - if(target->GetType() != cmTarget::SHARED_LIBRARY) + if(target->GetType() != cmState::SHARED_LIBRARY) { return; } // Try to get the soname of the library. Only files with this name // could possibly conflict. - cmGeneratorTarget *gtgt = this->GlobalGenerator->GetGeneratorTarget(target); - std::string soName = gtgt->GetSOName(this->Config); + std::string soName = target->GetSOName(this->Config); const char* soname = soName.empty()? 0 : soName.c_str(); // Include this library in the runtime path ordering. @@ -1918,9 +1911,9 @@ void cmComputeLinkInformation::GetRPath(std::vector<std::string>& runtimeDirs, // build tree. bool linking_for_install = (for_install || - this->Target->Target->GetPropertyAsBool("BUILD_WITH_INSTALL_RPATH")); + this->Target->GetPropertyAsBool("BUILD_WITH_INSTALL_RPATH")); bool use_install_rpath = - (outputRuntime && this->Target->Target->HaveInstallTreeRPATH() && + (outputRuntime && this->Target->HaveInstallTreeRPATH() && linking_for_install); bool use_build_rpath = (outputRuntime && this->Target->HaveBuildTreeRPATH(this->Config) && @@ -1928,14 +1921,14 @@ void cmComputeLinkInformation::GetRPath(std::vector<std::string>& runtimeDirs, bool use_link_rpath = outputRuntime && linking_for_install && !this->Makefile->IsOn("CMAKE_SKIP_INSTALL_RPATH") && - this->Target->Target->GetPropertyAsBool("INSTALL_RPATH_USE_LINK_PATH"); + this->Target->GetPropertyAsBool("INSTALL_RPATH_USE_LINK_PATH"); // Construct the RPATH. std::set<std::string> emitted; if(use_install_rpath) { const char* install_rpath = - this->Target->Target->GetProperty("INSTALL_RPATH"); + this->Target->GetProperty("INSTALL_RPATH"); cmCLI_ExpandListUnique(install_rpath, runtimeDirs, emitted); } if(use_build_rpath || use_link_rpath) @@ -1975,8 +1968,9 @@ void cmComputeLinkInformation::GetRPath(std::vector<std::string>& runtimeDirs, else if(use_link_rpath) { // Do not add any path inside the source or build tree. - const char* topSourceDir = this->Makefile->GetHomeDirectory(); - const char* topBinaryDir = this->Makefile->GetHomeOutputDirectory(); + const char* topSourceDir = this->CMakeInstance->GetHomeDirectory(); + const char* topBinaryDir = + this->CMakeInstance->GetHomeOutputDirectory(); if(!cmSystemTools::ComparePath(*ri, topSourceDir) && !cmSystemTools::ComparePath(*ri, topBinaryDir) && !cmSystemTools::IsSubDirectory(*ri, topSourceDir) && diff --git a/Source/cmComputeLinkInformation.h b/Source/cmComputeLinkInformation.h index 8b83574..5eecf7d 100644 --- a/Source/cmComputeLinkInformation.h +++ b/Source/cmComputeLinkInformation.h @@ -19,7 +19,6 @@ class cmake; class cmGlobalGenerator; class cmMakefile; -class cmTarget; class cmGeneratorTarget; class cmOrderDirectories; @@ -39,11 +38,11 @@ public: Item(): Value(), IsPath(true), Target(0) {} Item(Item const& item): Value(item.Value), IsPath(item.IsPath), Target(item.Target) {} - Item(std::string const& v, bool p, cmTarget const* target = 0): + Item(std::string const& v, bool p, cmGeneratorTarget const* target = 0): Value(v), IsPath(p), Target(target) {} std::string Value; bool IsPath; - cmTarget const* Target; + cmGeneratorTarget const* Target; }; typedef std::vector<Item> ItemVector; ItemVector const& GetItems(); @@ -57,13 +56,13 @@ public: void GetRPath(std::vector<std::string>& runtimeDirs, bool for_install); std::string GetRPathString(bool for_install); std::string GetChrpathString(); - std::set<cmTarget const*> const& GetSharedLibrariesLinked(); + std::set<cmGeneratorTarget const*> const& GetSharedLibrariesLinked(); std::string const& GetRPathLinkFlag() const { return this->RPathLinkFlag; } std::string GetRPathLinkString(); private: - void AddItem(std::string const& item, cmTarget const* tgt); - void AddSharedDepItem(std::string const& item, cmTarget const* tgt); + void AddItem(std::string const& item, const cmGeneratorTarget* tgt); + void AddSharedDepItem(std::string const& item, cmGeneratorTarget const* tgt); // Output information. ItemVector Items; @@ -71,7 +70,7 @@ private: std::vector<std::string> Depends; std::vector<std::string> FrameworkPaths; std::vector<std::string> RuntimeSearchPath; - std::set<cmTarget const*> SharedLibrariesLinked; + std::set<cmGeneratorTarget const*> SharedLibrariesLinked; // Context information. cmGeneratorTarget const* Target; @@ -129,7 +128,7 @@ private: std::string NoCaseExpression(const char* str); // Handling of link items. - void AddTargetItem(std::string const& item, cmTarget const* target); + void AddTargetItem(std::string const& item, const cmGeneratorTarget* target); void AddFullItem(std::string const& item); bool CheckImplicitDirItem(std::string const& item); void AddUserItem(std::string const& item, bool pathNotKnown); @@ -183,7 +182,7 @@ private: bool CMP0060Warn; void AddLibraryRuntimeInfo(std::string const& fullPath, - cmTarget const* target); + const cmGeneratorTarget* target); void AddLibraryRuntimeInfo(std::string const& fullPath); }; diff --git a/Source/cmComputeTargetDepends.cxx b/Source/cmComputeTargetDepends.cxx index 9e37c35..586b5bf 100644 --- a/Source/cmComputeTargetDepends.cxx +++ b/Source/cmComputeTargetDepends.cxx @@ -175,13 +175,12 @@ void cmComputeTargetDepends::CollectTargets() this->GlobalGenerator->GetLocalGenerators(); for(unsigned int i = 0; i < lgens.size(); ++i) { - const cmTargets& targets = lgens[i]->GetMakefile()->GetTargets(); - for(cmTargets::const_iterator ti = targets.begin(); + const std::vector<cmGeneratorTarget*> targets = + lgens[i]->GetGeneratorTargets(); + for(std::vector<cmGeneratorTarget*>::const_iterator ti = targets.begin(); ti != targets.end(); ++ti) { - cmTarget const* target = &ti->second; - cmGeneratorTarget* gt = - this->GlobalGenerator->GetGeneratorTarget(target); + cmGeneratorTarget* gt = *ti; int index = static_cast<int>(this->Targets.size()); this->TargetIndex[gt] = index; this->Targets.push_back(gt); @@ -207,7 +206,7 @@ void cmComputeTargetDepends::CollectTargetDepends(int depender_index) { // Get the depender. cmGeneratorTarget const* depender = this->Targets[depender_index]; - if (depender->GetType() == cmTarget::INTERFACE_LIBRARY) + if (depender->GetType() == cmState::INTERFACE_LIBRARY) { return; } @@ -236,16 +235,16 @@ void cmComputeTargetDepends::CollectTargetDepends(int depender_index) std::string objLib = (*oi)->GetObjectLibrary(); if (!objLib.empty() && emitted.insert(objLib).second) { - if(depender->GetType() != cmTarget::EXECUTABLE && - depender->GetType() != cmTarget::STATIC_LIBRARY && - depender->GetType() != cmTarget::SHARED_LIBRARY && - depender->GetType() != cmTarget::MODULE_LIBRARY) + if(depender->GetType() != cmState::EXECUTABLE && + depender->GetType() != cmState::STATIC_LIBRARY && + depender->GetType() != cmState::SHARED_LIBRARY && + depender->GetType() != cmState::MODULE_LIBRARY) { this->GlobalGenerator->GetCMakeInstance() ->IssueMessage(cmake::FATAL_ERROR, "Only executables and non-OBJECT libraries may " "reference target objects.", - depender->Target->GetBacktrace()); + depender->GetBacktrace()); return; } const_cast<cmGeneratorTarget*>(depender)->Target->AddUtility(objLib); @@ -272,7 +271,7 @@ void cmComputeTargetDepends::CollectTargetDepends(int depender_index) // Loop over all utility dependencies. { - std::set<cmLinkItem> const& tutils = depender->Target->GetUtilityItems(); + std::set<cmLinkItem> const& tutils = depender->GetUtilityItems(); std::set<std::string> emitted; // A target should not depend on itself. emitted.insert(depender->GetName()); @@ -297,7 +296,7 @@ void cmComputeTargetDepends::AddInterfaceDepends(int depender_index, cmGeneratorTarget const* depender = this->Targets[depender_index]; if(cmLinkInterface const* iface = dependee->GetLinkInterface(config, - depender->Target)) + depender)) { for(std::vector<cmLinkItem>::const_iterator lib = iface->Libraries.begin(); @@ -319,12 +318,12 @@ void cmComputeTargetDepends::AddInterfaceDepends(int depender_index, std::set<std::string> &emitted) { cmGeneratorTarget const* depender = this->Targets[depender_index]; - cmTarget const* dependee = dependee_name.Target; + cmGeneratorTarget const* dependee = dependee_name.Target; // Skip targets that will not really be linked. This is probably a // name conflict between an external library and an executable // within the project. if(dependee && - dependee->GetType() == cmTarget::EXECUTABLE && + dependee->GetType() == cmState::EXECUTABLE && !dependee->IsExecutableWithExports()) { dependee = 0; @@ -332,9 +331,7 @@ void cmComputeTargetDepends::AddInterfaceDepends(int depender_index, if(dependee) { - cmGeneratorTarget* gt = - this->GlobalGenerator->GetGeneratorTarget(dependee); - this->AddInterfaceDepends(depender_index, gt, "", emitted); + this->AddInterfaceDepends(depender_index, dependee, "", emitted); std::vector<std::string> configs; depender->Makefile->GetConfigurations(configs); for (std::vector<std::string>::const_iterator it = configs.begin(); @@ -342,7 +339,7 @@ void cmComputeTargetDepends::AddInterfaceDepends(int depender_index, { // A target should not depend on itself. emitted.insert(depender->GetName()); - this->AddInterfaceDepends(depender_index, gt, *it, emitted); + this->AddInterfaceDepends(depender_index, dependee, *it, emitted); } } } @@ -356,15 +353,15 @@ void cmComputeTargetDepends::AddTargetDepend( cmGeneratorTarget const* depender = this->Targets[depender_index]; // Check the target's makefile first. - cmTarget const* dependee = dependee_name.Target; + cmGeneratorTarget const* dependee = dependee_name.Target; if(!dependee && !linking && - (depender->GetType() != cmTarget::GLOBAL_TARGET)) + (depender->GetType() != cmState::GLOBAL_TARGET)) { cmake::MessageType messageType = cmake::AUTHOR_WARNING; bool issueMessage = false; std::ostringstream e; - switch(depender->Target->GetPolicyStatusCMP0046()) + switch(depender->GetPolicyStatusCMP0046()) { case cmPolicies::WARN: e << cmPolicies::GetPolicyWarning(cmPolicies::CMP0046) << "\n"; @@ -385,7 +382,7 @@ void cmComputeTargetDepends::AddTargetDepend( << "\" of target \"" << depender->GetName() << "\" does not exist."; cmListFileBacktrace const* backtrace = - depender->Target->GetUtilityBacktrace(dependee_name); + depender->GetUtilityBacktrace(dependee_name); if(backtrace) { cm->IssueMessage(messageType, e.str(), *backtrace); @@ -402,7 +399,7 @@ void cmComputeTargetDepends::AddTargetDepend( // name conflict between an external library and an executable // within the project. if(linking && dependee && - dependee->GetType() == cmTarget::EXECUTABLE && + dependee->GetType() == cmState::EXECUTABLE && !dependee->IsExecutableWithExports()) { dependee = 0; @@ -410,9 +407,7 @@ void cmComputeTargetDepends::AddTargetDepend( if(dependee) { - cmGeneratorTarget* gt = - this->GlobalGenerator->GetGeneratorTarget(dependee); - this->AddTargetDepend(depender_index, gt, linking); + this->AddTargetDepend(depender_index, dependee, linking); } } @@ -421,20 +416,18 @@ void cmComputeTargetDepends::AddTargetDepend(int depender_index, const cmGeneratorTarget* dependee, bool linking) { - if(dependee->Target->IsImported() || - dependee->GetType() == cmTarget::INTERFACE_LIBRARY) + if(dependee->IsImported() || + dependee->GetType() == cmState::INTERFACE_LIBRARY) { // Skip IMPORTED and INTERFACE targets but follow their utility // dependencies. - std::set<cmLinkItem> const& utils = dependee->Target->GetUtilityItems(); + std::set<cmLinkItem> const& utils = dependee->GetUtilityItems(); for(std::set<cmLinkItem>::const_iterator i = utils.begin(); i != utils.end(); ++i) { - if(cmTarget const* transitive_dependee = i->Target) + if(cmGeneratorTarget const* transitive_dependee = i->Target) { - cmGeneratorTarget* gt = - this->GlobalGenerator->GetGeneratorTarget(transitive_dependee); - this->AddTargetDepend(depender_index, gt, false); + this->AddTargetDepend(depender_index, transitive_dependee, false); } } } @@ -529,7 +522,7 @@ cmComputeTargetDepends // Make sure the component is all STATIC_LIBRARY targets. for(NodeList::const_iterator ni = nl.begin(); ni != nl.end(); ++ni) { - if(this->Targets[*ni]->GetType() != cmTarget::STATIC_LIBRARY) + if(this->Targets[*ni]->GetType() != cmState::STATIC_LIBRARY) { this->ComplainAboutBadComponent(ccg, c); return false; @@ -560,7 +553,7 @@ cmComputeTargetDepends // Describe the depender. e << " \"" << depender->GetName() << "\" of type " - << cmTarget::GetTargetTypeName(depender->Target->GetType()) << "\n"; + << cmState::GetTargetTypeName(depender->GetType()) << "\n"; // List its dependencies that are inside the component. EdgeList const& nl = this->InitialGraph[i]; diff --git a/Source/cmCoreTryCompile.cxx b/Source/cmCoreTryCompile.cxx index 3d9c4bf..4a1f770 100644 --- a/Source/cmCoreTryCompile.cxx +++ b/Source/cmCoreTryCompile.cxx @@ -34,7 +34,7 @@ int cmCoreTryCompile::TryCompileCode(std::vector<std::string> const& argv) std::string outputVariable; std::string copyFile; std::string copyFileError; - std::vector<cmTarget const*> targets; + std::vector<std::string> targets; std::string libsToLink = " "; bool useOldLinkLibs = true; char targetNameBuf[64]; @@ -93,12 +93,12 @@ int cmCoreTryCompile::TryCompileCode(std::vector<std::string> const& argv) { switch(tgt->GetType()) { - case cmTarget::SHARED_LIBRARY: - case cmTarget::STATIC_LIBRARY: - case cmTarget::INTERFACE_LIBRARY: - case cmTarget::UNKNOWN_LIBRARY: + case cmState::SHARED_LIBRARY: + case cmState::STATIC_LIBRARY: + case cmState::INTERFACE_LIBRARY: + case cmState::UNKNOWN_LIBRARY: break; - case cmTarget::EXECUTABLE: + case cmState::EXECUTABLE: if (tgt->IsExecutableWithExports()) { break; @@ -107,12 +107,12 @@ int cmCoreTryCompile::TryCompileCode(std::vector<std::string> const& argv) this->Makefile->IssueMessage(cmake::FATAL_ERROR, "Only libraries may be used as try_compile or try_run IMPORTED " "LINK_LIBRARIES. Got " + std::string(tgt->GetName()) + " of " - "type " + tgt->GetTargetTypeName(tgt->GetType()) + "."); + "type " + cmState::GetTargetTypeName(tgt->GetType()) + "."); return -1; } if (tgt->IsImported()) { - targets.push_back(tgt); + targets.push_back(argv[i]); } } } @@ -375,9 +375,8 @@ int cmCoreTryCompile::TryCompileCode(std::vector<std::string> const& argv) if (!targets.empty()) { std::string fname = "/" + std::string(targetName) + "Targets.cmake"; - cmExportTryCompileFileGenerator tcfg(gg); + cmExportTryCompileFileGenerator tcfg(gg, targets, this->Makefile); tcfg.SetExportFile((this->BinaryDirectory + fname).c_str()); - tcfg.SetExports(targets); tcfg.SetConfig(this->Makefile->GetSafeDefinition( "CMAKE_TRY_COMPILE_CONFIGURATION")); diff --git a/Source/cmCustomCommandGenerator.cxx b/Source/cmCustomCommandGenerator.cxx index 7f3b651..dc06678 100644 --- a/Source/cmCustomCommandGenerator.cxx +++ b/Source/cmCustomCommandGenerator.cxx @@ -43,15 +43,14 @@ std::string cmCustomCommandGenerator::GetCommand(unsigned int c) const { std::string const& argv0 = this->CC.GetCommandLines()[c][0]; cmGeneratorTarget* target = - this->LG->GetMakefile()->FindGeneratorTargetToUse(argv0); - if(target && target->GetType() == cmTarget::EXECUTABLE && - (target->Target->IsImported() + this->LG->FindGeneratorTargetToUse(argv0); + if(target && target->GetType() == cmState::EXECUTABLE && + (target->IsImported() || !this->LG->GetMakefile()->IsOn("CMAKE_CROSSCOMPILING"))) { return target->GetLocation(this->Config); } - return this->GE->Parse(argv0)->Evaluate(this->LG->GetMakefile(), - this->Config); + return this->GE->Parse(argv0)->Evaluate(this->LG, this->Config); } //---------------------------------------------------------------------------- @@ -92,7 +91,7 @@ cmCustomCommandGenerator for(unsigned int j=1;j < commandLine.size(); ++j) { std::string arg = - this->GE->Parse(commandLine[j])->Evaluate(this->LG->GetMakefile(), + this->GE->Parse(commandLine[j])->Evaluate(this->LG, this->Config); cmd += " "; if(this->OldStyle) @@ -101,7 +100,7 @@ cmCustomCommandGenerator } else { - cmOutputConverter converter(this->LG->GetMakefile()->GetStateSnapshot()); + cmOutputConverter converter(this->LG->GetStateSnapshot()); cmd += converter.EscapeForShell(arg, this->MakeVars); } } @@ -146,7 +145,7 @@ std::vector<std::string> const& cmCustomCommandGenerator::GetDepends() const = this->GE->Parse(*i); std::vector<std::string> result; cmSystemTools::ExpandListArgument( - cge->Evaluate(this->LG->GetMakefile(), this->Config), result); + cge->Evaluate(this->LG, this->Config), result); for (std::vector<std::string>::iterator it = result.begin(); it != result.end(); ++it) { diff --git a/Source/cmDependsFortran.cxx b/Source/cmDependsFortran.cxx index 856dcd4..80f560f 100644 --- a/Source/cmDependsFortran.cxx +++ b/Source/cmDependsFortran.cxx @@ -160,7 +160,7 @@ bool cmDependsFortran::Finalize(std::ostream& makeDepends, if (mod_dir.empty()) { mod_dir = - this->LocalGenerator->GetMakefile()->GetCurrentBinaryDirectory(); + this->LocalGenerator->GetCurrentBinaryDirectory(); } // Actually write dependencies to the streams. diff --git a/Source/cmELF.cxx b/Source/cmELF.cxx index d062987..37dd328 100644 --- a/Source/cmELF.cxx +++ b/Source/cmELF.cxx @@ -567,8 +567,14 @@ bool cmELFInternalImpl<Types>::LoadDynamicSection() return true; } - // Allocate the dynamic section entries. + // If there are no entries we are done. ELF_Shdr const& sec = this->SectionHeaders[this->DynamicSectionIndex]; + if(sec.sh_entsize == 0) + { + return false; + } + + // Allocate the dynamic section entries. int n = static_cast<int>(sec.sh_size / sec.sh_entsize); this->DynamicSectionEntries.resize(n); diff --git a/Source/cmEnableTestingCommand.cxx b/Source/cmEnableTestingCommand.cxx index aa41ef7..6a7fd46 100644 --- a/Source/cmEnableTestingCommand.cxx +++ b/Source/cmEnableTestingCommand.cxx @@ -10,7 +10,6 @@ See the License for more information. ============================================================================*/ #include "cmEnableTestingCommand.h" -#include "cmLocalGenerator.h" // we do this in the final pass so that we now the subdirs have all // been defined diff --git a/Source/cmExportBuildFileGenerator.cxx b/Source/cmExportBuildFileGenerator.cxx index fed0dbc..dcb2187 100644 --- a/Source/cmExportBuildFileGenerator.cxx +++ b/Source/cmExportBuildFileGenerator.cxx @@ -18,16 +18,24 @@ //---------------------------------------------------------------------------- cmExportBuildFileGenerator::cmExportBuildFileGenerator() - : Backtrace() { - this->Makefile = 0; + this->LG = 0; this->ExportSet = 0; } //---------------------------------------------------------------------------- +void cmExportBuildFileGenerator::Compute(cmLocalGenerator* lg) +{ + this->LG = lg; + if (this->ExportSet) + { + this->ExportSet->Compute(lg); + } +} + +//---------------------------------------------------------------------------- bool cmExportBuildFileGenerator::GenerateMainFile(std::ostream& os) { - std::vector<cmGeneratorTarget*> allTargets; { std::string expectedTargets; std::string sep; @@ -37,11 +45,11 @@ bool cmExportBuildFileGenerator::GenerateMainFile(std::ostream& os) tei = targets.begin(); tei != targets.end(); ++tei) { - cmGeneratorTarget *te = this->Makefile + cmGeneratorTarget *te = this->LG ->FindGeneratorTargetToUse(*tei); - expectedTargets += sep + this->Namespace + te->Target->GetExportName(); + expectedTargets += sep + this->Namespace + te->GetExportName(); sep = " "; - if(this->ExportedTargets.insert(te->Target).second) + if(this->ExportedTargets.insert(te).second) { this->Exports.push_back(te); } @@ -49,11 +57,12 @@ bool cmExportBuildFileGenerator::GenerateMainFile(std::ostream& os) { std::ostringstream e; e << "given target \"" << te->GetName() << "\" more than once."; - this->Makefile->GetCMakeInstance() - ->IssueMessage(cmake::FATAL_ERROR, e.str(), this->Backtrace); + this->LG->GetGlobalGenerator()->GetCMakeInstance() + ->IssueMessage(cmake::FATAL_ERROR, e.str(), + this->LG->GetMakefile()->GetBacktrace()); return false; } - if (te->GetType() == cmTarget::INTERFACE_LIBRARY) + if (te->GetType() == cmState::INTERFACE_LIBRARY) { this->GenerateRequiredCMakeVersion(os, "3.0.0"); } @@ -70,45 +79,44 @@ bool cmExportBuildFileGenerator::GenerateMainFile(std::ostream& os) tei != this->Exports.end(); ++tei) { cmGeneratorTarget* gte = *tei; - cmTarget* te = gte->Target; - this->GenerateImportTargetCode(os, te); + this->GenerateImportTargetCode(os, gte); - te->AppendBuildInterfaceIncludes(); + gte->Target->AppendBuildInterfaceIncludes(); ImportPropertyMap properties; - this->PopulateInterfaceProperty("INTERFACE_INCLUDE_DIRECTORIES", te, + this->PopulateInterfaceProperty("INTERFACE_INCLUDE_DIRECTORIES", gte, cmGeneratorExpression::BuildInterface, properties, missingTargets); - this->PopulateInterfaceProperty("INTERFACE_SOURCES", te, + this->PopulateInterfaceProperty("INTERFACE_SOURCES", gte, cmGeneratorExpression::BuildInterface, properties, missingTargets); - this->PopulateInterfaceProperty("INTERFACE_COMPILE_DEFINITIONS", te, + this->PopulateInterfaceProperty("INTERFACE_COMPILE_DEFINITIONS", gte, cmGeneratorExpression::BuildInterface, properties, missingTargets); - this->PopulateInterfaceProperty("INTERFACE_COMPILE_OPTIONS", te, + this->PopulateInterfaceProperty("INTERFACE_COMPILE_OPTIONS", gte, cmGeneratorExpression::BuildInterface, properties, missingTargets); - this->PopulateInterfaceProperty("INTERFACE_AUTOUIC_OPTIONS", te, + this->PopulateInterfaceProperty("INTERFACE_AUTOUIC_OPTIONS", gte, cmGeneratorExpression::BuildInterface, properties, missingTargets); - this->PopulateInterfaceProperty("INTERFACE_COMPILE_FEATURES", te, + this->PopulateInterfaceProperty("INTERFACE_COMPILE_FEATURES", gte, cmGeneratorExpression::BuildInterface, properties, missingTargets); this->PopulateInterfaceProperty("INTERFACE_POSITION_INDEPENDENT_CODE", - te, properties); + gte, properties); const bool newCMP0022Behavior = - te->GetPolicyStatusCMP0022() != cmPolicies::WARN - && te->GetPolicyStatusCMP0022() != cmPolicies::OLD; + gte->GetPolicyStatusCMP0022() != cmPolicies::WARN + && gte->GetPolicyStatusCMP0022() != cmPolicies::OLD; if (newCMP0022Behavior) { - this->PopulateInterfaceLinkLibrariesProperty(te, + this->PopulateInterfaceLinkLibrariesProperty(gte, cmGeneratorExpression::BuildInterface, properties, missingTargets); } this->PopulateCompatibleInterfaceProperties(gte, properties); - this->GenerateInterfaceProperties(te, os, properties); + this->GenerateInterfaceProperties(gte, os, properties); } // Generate import file content for each configuration. @@ -140,14 +148,14 @@ cmExportBuildFileGenerator cmGeneratorTarget* target = *tei; ImportPropertyMap properties; - if (target->GetType() != cmTarget::INTERFACE_LIBRARY) + if (target->GetType() != cmState::INTERFACE_LIBRARY) { this->SetImportLocationProperty(config, suffix, target, properties); } if(!properties.empty()) { // Get the rest of the target details. - if (target->GetType() != cmTarget::INTERFACE_LIBRARY) + if (target->GetType() != cmState::INTERFACE_LIBRARY) { this->SetImportDetailProperties(config, suffix, target, @@ -165,7 +173,7 @@ cmExportBuildFileGenerator // properties); // Generate code in the export file. - this->GenerateImportPropertyCode(os, config, target->Target, + this->GenerateImportPropertyCode(os, config, target, properties); } } @@ -193,7 +201,7 @@ cmExportBuildFileGenerator std::string prop = "IMPORTED_LOCATION"; prop += suffix; std::string value; - if(target->Target->IsAppBundleOnApple()) + if(target->IsAppBundleOnApple()) { value = target->GetFullPath(config, false); } @@ -204,20 +212,16 @@ cmExportBuildFileGenerator properties[prop] = value; } - // Check whether this is a DLL platform. - bool dll_platform = - (mf->IsOn("WIN32") || mf->IsOn("CYGWIN") || mf->IsOn("MINGW")); - // Add the import library for windows DLLs. - if(dll_platform && - (target->GetType() == cmTarget::SHARED_LIBRARY || - target->Target->IsExecutableWithExports()) && + if(target->IsDLLPlatform() && + (target->GetType() == cmState::SHARED_LIBRARY || + target->IsExecutableWithExports()) && mf->GetDefinition("CMAKE_IMPORT_LIBRARY_SUFFIX")) { std::string prop = "IMPORTED_IMPLIB"; prop += suffix; std::string value = target->GetFullPath(config, true); - target->Target->GetImplibGNUtoMS(value, value, + target->GetImplibGNUtoMS(value, value, "${CMAKE_IMPORT_LIBRARY_SUFFIX}"); properties[prop] = value; } @@ -226,14 +230,18 @@ cmExportBuildFileGenerator //---------------------------------------------------------------------------- void cmExportBuildFileGenerator::HandleMissingTarget( - std::string& link_libs, std::vector<std::string>& missingTargets, - cmMakefile* mf, cmTarget* depender, cmTarget* dependee) + std::string& link_libs, + std::vector<std::string>& missingTargets, + cmGeneratorTarget* depender, + cmGeneratorTarget* dependee) { // The target is not in the export. if(!this->AppendMode) { const std::string name = dependee->GetName(); - std::vector<std::string> namespaces = this->FindNamespaces(mf, name); + cmGlobalGenerator* gg = + dependee->GetLocalGenerator()->GetGlobalGenerator(); + std::vector<std::string> namespaces = this->FindNamespaces(gg, name); int targetOccurrences = (int)namespaces.size(); if (targetOccurrences == 1) @@ -268,7 +276,7 @@ void cmExportBuildFileGenerator tei = this->ExportSet->GetTargetExports()->begin(); tei != this->ExportSet->GetTargetExports()->end(); ++tei) { - targets.push_back((*tei)->Target->GetName()); + targets.push_back((*tei)->TargetName); } return; } @@ -278,10 +286,9 @@ void cmExportBuildFileGenerator //---------------------------------------------------------------------------- std::vector<std::string> cmExportBuildFileGenerator -::FindNamespaces(cmMakefile* mf, const std::string& name) +::FindNamespaces(cmGlobalGenerator* gg, const std::string& name) { std::vector<std::string> namespaces; - cmGlobalGenerator* gg = mf->GetGlobalGenerator(); std::map<std::string, cmExportBuildFileGenerator*>& exportSets = gg->GetBuildExportSets(); @@ -304,8 +311,8 @@ cmExportBuildFileGenerator //---------------------------------------------------------------------------- void cmExportBuildFileGenerator -::ComplainAboutMissingTarget(cmTarget* depender, - cmTarget* dependee, +::ComplainAboutMissingTarget(cmGeneratorTarget* depender, + cmGeneratorTarget* dependee, int occurrences) { if(cmSystemTools::GetErrorOccuredFlag()) @@ -328,8 +335,9 @@ cmExportBuildFileGenerator e << "If the required target is not easy to reference in this call, " << "consider using the APPEND option with multiple separate calls."; - this->Makefile->GetCMakeInstance() - ->IssueMessage(cmake::FATAL_ERROR, e.str(), this->Backtrace); + this->LG->GetGlobalGenerator()->GetCMakeInstance() + ->IssueMessage(cmake::FATAL_ERROR, e.str(), + this->LG->GetMakefile()->GetBacktrace()); } std::string diff --git a/Source/cmExportBuildFileGenerator.h b/Source/cmExportBuildFileGenerator.h index ff3d2e1..85aae2f 100644 --- a/Source/cmExportBuildFileGenerator.h +++ b/Source/cmExportBuildFileGenerator.h @@ -43,10 +43,7 @@ public: /** Set whether to append generated code to the output file. */ void SetAppendMode(bool append) { this->AppendMode = append; } - void SetMakefile(cmMakefile *mf) { - this->Makefile = mf; - this->Backtrace = this->Makefile->GetBacktrace(); - } + void Compute(cmLocalGenerator* lg); protected: // Implement virtual methods from the superclass. @@ -57,12 +54,11 @@ protected: std::vector<std::string> &missingTargets); virtual void HandleMissingTarget(std::string& link_libs, std::vector<std::string>& missingTargets, - cmMakefile* mf, - cmTarget* depender, - cmTarget* dependee); + cmGeneratorTarget* depender, + cmGeneratorTarget* dependee); - void ComplainAboutMissingTarget(cmTarget* depender, - cmTarget* dependee, + void ComplainAboutMissingTarget(cmGeneratorTarget* depender, + cmGeneratorTarget* dependee, int occurrences); /** Fill in properties indicating built file locations. */ @@ -75,13 +71,12 @@ protected: const std::string& config); std::vector<std::string> - FindNamespaces(cmMakefile* mf, const std::string& name); + FindNamespaces(cmGlobalGenerator* gg, const std::string& name); std::vector<std::string> Targets; cmExportSet *ExportSet; std::vector<cmGeneratorTarget*> Exports; - cmMakefile* Makefile; - cmListFileBacktrace Backtrace; + cmLocalGenerator* LG; }; #endif diff --git a/Source/cmExportCommand.cxx b/Source/cmExportCommand.cxx index 96ea77b..4eec66a 100644 --- a/Source/cmExportCommand.cxx +++ b/Source/cmExportCommand.cxx @@ -11,7 +11,6 @@ ============================================================================*/ #include "cmExportCommand.h" #include "cmGlobalGenerator.h" -#include "cmLocalGenerator.h" #include "cmGeneratedFileStream.h" #include "cmake.h" @@ -169,7 +168,7 @@ bool cmExportCommand if(cmTarget* target = gg->FindTarget(*currentTarget)) { - if(target->GetType() == cmTarget::OBJECT_LIBRARY) + if(target->GetType() == cmState::OBJECT_LIBRARY) { std::ostringstream e; e << "given OBJECT library \"" << *currentTarget @@ -177,7 +176,7 @@ bool cmExportCommand this->SetError(e.str()); return false; } - if (target->GetType() == cmTarget::UTILITY) + if (target->GetType() == cmState::UTILITY) { this->SetError("given custom target \"" + *currentTarget + "\" which may not be exported."); @@ -222,7 +221,7 @@ bool cmExportCommand { ebfg->SetTargets(targets); } - ebfg->SetMakefile(this->Makefile); + this->Makefile->AddExportBuildFileGenerator(ebfg); ebfg->SetExportOld(this->ExportOld.IsEnabled()); // Compute the set of configurations exported. diff --git a/Source/cmExportFileGenerator.cxx b/Source/cmExportFileGenerator.cxx index 9a7d73f..e8a2e6a 100644 --- a/Source/cmExportFileGenerator.cxx +++ b/Source/cmExportFileGenerator.cxx @@ -18,7 +18,6 @@ #include "cmLocalGenerator.h" #include "cmMakefile.h" #include "cmSystemTools.h" -#include "cmTarget.h" #include "cmTargetExport.h" #include "cmVersion.h" #include "cmComputeLinkInformation.h" @@ -155,7 +154,7 @@ void cmExportFileGenerator::GenerateImportConfig(std::ostream& os, //---------------------------------------------------------------------------- void cmExportFileGenerator::PopulateInterfaceProperty( const std::string& propName, - cmTarget *target, + cmGeneratorTarget *target, ImportPropertyMap &properties) { const char *input = target->GetProperty(propName); @@ -169,7 +168,7 @@ void cmExportFileGenerator::PopulateInterfaceProperty( void cmExportFileGenerator::PopulateInterfaceProperty( const std::string& propName, const std::string& outputName, - cmTarget *target, + cmGeneratorTarget *target, cmGeneratorExpression::PreprocessContext preprocessRule, ImportPropertyMap &properties, std::vector<std::string> &missingTargets) @@ -206,7 +205,7 @@ void cmExportFileGenerator::GenerateRequiredCMakeVersion(std::ostream& os, //---------------------------------------------------------------------------- bool cmExportFileGenerator::PopulateInterfaceLinkLibrariesProperty( - cmTarget *target, + cmGeneratorTarget *target, cmGeneratorExpression::PreprocessContext preprocessRule, ImportPropertyMap &properties, std::vector<std::string> &missingTargets) @@ -241,12 +240,14 @@ static bool isSubDirectory(const char* a, const char* b) //---------------------------------------------------------------------------- static bool checkInterfaceDirs(const std::string &prepro, - cmTarget *target, const std::string& prop) + cmGeneratorTarget *target, const std::string& prop) { const char* installDir = - target->GetMakefile()->GetSafeDefinition("CMAKE_INSTALL_PREFIX"); - const char* topSourceDir = target->GetMakefile()->GetHomeDirectory(); - const char* topBinaryDir = target->GetMakefile()->GetHomeOutputDirectory(); + target->Makefile->GetSafeDefinition("CMAKE_INSTALL_PREFIX"); + const char* topSourceDir = + target->GetLocalGenerator()->GetSourceDirectory(); + const char* topBinaryDir = + target->GetLocalGenerator()->GetBinaryDirectory(); std::vector<std::string> parts; cmGeneratorExpression::Split(prepro, parts); @@ -298,7 +299,7 @@ static bool checkInterfaceDirs(const std::string &prepro, e << "Target \"" << target->GetName() << "\" " << prop << " property contains relative path:\n" " \"" << *li << "\""; - target->GetMakefile()->IssueMessage(messageType, e.str()); + target->GetLocalGenerator()->IssueMessage(messageType, e.str()); } bool inBinary = isSubDirectory(li->c_str(), topBinaryDir); bool inSource = isSubDirectory(li->c_str(), topSourceDir); @@ -329,7 +330,7 @@ static bool checkInterfaceDirs(const std::string &prepro, "a subdirectory of the " << (inBinary ? "build" : "source") << " tree:\n \"" << (inBinary ? topBinaryDir : topSourceDir) << "\"" << std::endl; - target->GetMakefile()->IssueMessage(cmake::AUTHOR_WARNING, + target->GetLocalGenerator()->IssueMessage(cmake::AUTHOR_WARNING, s.str()); } case cmPolicies::OLD: @@ -352,7 +353,7 @@ static bool checkInterfaceDirs(const std::string &prepro, e << "Target \"" << target->GetName() << "\" " << prop << " property contains path:\n" " \"" << *li << "\"\nwhich is prefixed in the build directory."; - target->GetMakefile()->IssueMessage(messageType, e.str()); + target->GetLocalGenerator()->IssueMessage(messageType, e.str()); } if (!inSourceBuild) { @@ -361,7 +362,7 @@ static bool checkInterfaceDirs(const std::string &prepro, e << "Target \"" << target->GetName() << "\" " << prop << " property contains path:\n" " \"" << *li << "\"\nwhich is prefixed in the source directory."; - target->GetMakefile()->IssueMessage(messageType, e.str()); + target->GetLocalGenerator()->IssueMessage(messageType, e.str()); } } } @@ -396,11 +397,11 @@ void cmExportFileGenerator::PopulateSourcesInterface( ImportPropertyMap &properties, std::vector<std::string> &missingTargets) { - cmTarget *target = tei->Target; + cmGeneratorTarget* gt = tei->Target; assert(preprocessRule == cmGeneratorExpression::InstallInterface); const char *propName = "INTERFACE_SOURCES"; - const char *input = target->GetProperty(propName); + const char *input = gt->GetProperty(propName); if (!input) { @@ -418,10 +419,10 @@ void cmExportFileGenerator::PopulateSourcesInterface( true); if (!prepro.empty()) { - this->ResolveTargetsInGeneratorExpressions(prepro, target, + this->ResolveTargetsInGeneratorExpressions(prepro, gt, missingTargets); - if (!checkInterfaceDirs(prepro, target, propName)) + if (!checkInterfaceDirs(prepro, gt, propName)) { return; } @@ -436,7 +437,7 @@ void cmExportFileGenerator::PopulateIncludeDirectoriesInterface( ImportPropertyMap &properties, std::vector<std::string> &missingTargets) { - cmTarget *target = tei->Target; + cmGeneratorTarget *target = tei->Target; assert(preprocessRule == cmGeneratorExpression::InstallInterface); const char *propName = "INTERFACE_INCLUDE_DIRECTORIES"; @@ -450,18 +451,18 @@ void cmExportFileGenerator::PopulateIncludeDirectoriesInterface( true); this->ReplaceInstallPrefix(dirs); cmsys::auto_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(dirs); - std::string exportDirs = cge->Evaluate(target->GetMakefile(), "", + std::string exportDirs = cge->Evaluate(target->GetLocalGenerator(), "", false, target); if (cge->GetHadContextSensitiveCondition()) { - cmMakefile* mf = target->GetMakefile(); + cmLocalGenerator* lg = target->GetLocalGenerator(); std::ostringstream e; e << "Target \"" << target->GetName() << "\" is installed with " "INCLUDES DESTINATION set to a context sensitive path. Paths which " "depend on the configuration, policy values or the link interface are " "not supported. Consider using target_include_directories instead."; - mf->IssueMessage(cmake::FATAL_ERROR, e.str()); + lg->IssueMessage(cmake::FATAL_ERROR, e.str()); return; } @@ -500,7 +501,7 @@ void cmExportFileGenerator::PopulateIncludeDirectoriesInterface( //---------------------------------------------------------------------------- void cmExportFileGenerator::PopulateInterfaceProperty( const std::string& propName, - cmTarget *target, + cmGeneratorTarget* target, cmGeneratorExpression::PreprocessContext preprocessRule, ImportPropertyMap &properties, std::vector<std::string> &missingTargets) @@ -511,8 +512,9 @@ void cmExportFileGenerator::PopulateInterfaceProperty( //---------------------------------------------------------------------------- -void getPropertyContents(cmTarget const* tgt, const std::string& prop, - std::set<std::string> &ifaceProperties) +void getPropertyContents(cmGeneratorTarget const* tgt, + const std::string& prop, + std::set<std::string> &ifaceProperties) { const char *p = tgt->GetProperty(prop); if (!p) @@ -533,11 +535,11 @@ void getCompatibleInterfaceProperties(cmGeneratorTarget *target, if (!info) { - cmMakefile* mf = target->Target->GetMakefile(); + cmLocalGenerator* lg = target->GetLocalGenerator(); std::ostringstream e; e << "Exporting the target \"" << target->GetName() << "\" is not " "allowed since its linker language cannot be determined"; - mf->IssueMessage(cmake::FATAL_ERROR, e.str()); + lg->IssueMessage(cmake::FATAL_ERROR, e.str()); return; } @@ -571,31 +573,30 @@ void cmExportFileGenerator::PopulateCompatibleInterfaceProperties( cmGeneratorTarget *gtarget, ImportPropertyMap &properties) { - cmTarget *target = gtarget->Target; this->PopulateInterfaceProperty("COMPATIBLE_INTERFACE_BOOL", - target, properties); + gtarget, properties); this->PopulateInterfaceProperty("COMPATIBLE_INTERFACE_STRING", - target, properties); + gtarget, properties); this->PopulateInterfaceProperty("COMPATIBLE_INTERFACE_NUMBER_MIN", - target, properties); + gtarget, properties); this->PopulateInterfaceProperty("COMPATIBLE_INTERFACE_NUMBER_MAX", - target, properties); + gtarget, properties); std::set<std::string> ifaceProperties; - getPropertyContents(target, "COMPATIBLE_INTERFACE_BOOL", ifaceProperties); - getPropertyContents(target, "COMPATIBLE_INTERFACE_STRING", ifaceProperties); - getPropertyContents(target, "COMPATIBLE_INTERFACE_NUMBER_MIN", + getPropertyContents(gtarget, "COMPATIBLE_INTERFACE_BOOL", ifaceProperties); + getPropertyContents(gtarget, "COMPATIBLE_INTERFACE_STRING", ifaceProperties); + getPropertyContents(gtarget, "COMPATIBLE_INTERFACE_NUMBER_MIN", ifaceProperties); - getPropertyContents(target, "COMPATIBLE_INTERFACE_NUMBER_MAX", + getPropertyContents(gtarget, "COMPATIBLE_INTERFACE_NUMBER_MAX", ifaceProperties); - if (target->GetType() != cmTarget::INTERFACE_LIBRARY) + if (gtarget->GetType() != cmState::INTERFACE_LIBRARY) { getCompatibleInterfaceProperties(gtarget, ifaceProperties, ""); std::vector<std::string> configNames; - target->GetMakefile()->GetConfigurations(configNames); + gtarget->Target->GetMakefile()->GetConfigurations(configNames); for (std::vector<std::string>::const_iterator ci = configNames.begin(); ci != configNames.end(); ++ci) @@ -608,12 +609,13 @@ void cmExportFileGenerator::PopulateCompatibleInterfaceProperties( it != ifaceProperties.end(); ++it) { this->PopulateInterfaceProperty("INTERFACE_" + *it, - target, properties); + gtarget, properties); } } //---------------------------------------------------------------------------- -void cmExportFileGenerator::GenerateInterfaceProperties(cmTarget const* target, +void cmExportFileGenerator::GenerateInterfaceProperties( + const cmGeneratorTarget* target, std::ostream& os, const ImportPropertyMap &properties) { @@ -635,12 +637,12 @@ void cmExportFileGenerator::GenerateInterfaceProperties(cmTarget const* target, //---------------------------------------------------------------------------- bool cmExportFileGenerator::AddTargetNamespace(std::string &input, - cmTarget* target, + cmGeneratorTarget* target, std::vector<std::string> &missingTargets) { - cmMakefile *mf = target->GetMakefile(); + cmLocalGenerator *lg = target->GetLocalGenerator(); - cmTarget *tgt = mf->FindTargetToUse(input); + cmGeneratorTarget *tgt = lg->FindGeneratorTargetToUse(input); if (!tgt) { return false; @@ -658,7 +660,7 @@ cmExportFileGenerator::AddTargetNamespace(std::string &input, { std::string namespacedTarget; this->HandleMissingTarget(namespacedTarget, missingTargets, - mf, target, tgt); + target, tgt); if (!namespacedTarget.empty()) { input = namespacedTarget; @@ -671,7 +673,7 @@ cmExportFileGenerator::AddTargetNamespace(std::string &input, void cmExportFileGenerator::ResolveTargetsInGeneratorExpressions( std::string &input, - cmTarget* target, + cmGeneratorTarget* target, std::vector<std::string> &missingTargets, FreeTargetsReplace replace) { @@ -708,14 +710,12 @@ cmExportFileGenerator::ResolveTargetsInGeneratorExpressions( void cmExportFileGenerator::ResolveTargetsInGeneratorExpression( std::string &input, - cmTarget* target, + cmGeneratorTarget* target, std::vector<std::string> &missingTargets) { std::string::size_type pos = 0; std::string::size_type lastPos = pos; - cmMakefile *mf = target->GetMakefile(); - while((pos = input.find("$<TARGET_PROPERTY:", lastPos)) != input.npos) { std::string::size_type nameStartPos = pos + @@ -776,7 +776,7 @@ cmExportFileGenerator::ResolveTargetsInGeneratorExpression( if (!errorString.empty()) { - mf->IssueMessage(cmake::FATAL_ERROR, errorString); + target->GetLocalGenerator()->IssueMessage(cmake::FATAL_ERROR, errorString); } } @@ -797,7 +797,7 @@ cmExportFileGenerator { // Add the transitive link dependencies for this configuration. cmLinkInterface const* iface = target->GetLinkInterface(config, - target->Target); + target); if (!iface) { return; @@ -830,20 +830,18 @@ cmExportFileGenerator } const bool newCMP0022Behavior = - target->Target - ->GetPolicyStatusCMP0022() != cmPolicies::WARN - && target->Target - ->GetPolicyStatusCMP0022() != cmPolicies::OLD; + target->GetPolicyStatusCMP0022() != cmPolicies::WARN + && target->GetPolicyStatusCMP0022() != cmPolicies::OLD; if(newCMP0022Behavior && !this->ExportOld) { - cmMakefile *mf = target->Target->GetMakefile(); + cmLocalGenerator *lg = target->GetLocalGenerator(); std::ostringstream e; e << "Target \"" << target->GetName() << "\" has policy CMP0022 enabled, " "but also has old-style LINK_INTERFACE_LIBRARIES properties " "populated, but it was exported without the " "EXPORT_LINK_INTERFACE_LIBRARIES to export the old-style properties"; - mf->IssueMessage(cmake::FATAL_ERROR, e.str()); + lg->IssueMessage(cmake::FATAL_ERROR, e.str()); return; } @@ -857,7 +855,7 @@ cmExportFileGenerator preprocessRule); if (!prepro.empty()) { - this->ResolveTargetsInGeneratorExpressions(prepro, target->Target, + this->ResolveTargetsInGeneratorExpressions(prepro, target, missingTargets, ReplaceFreeTargets); properties["IMPORTED_LINK_INTERFACE_LIBRARIES" + suffix] = prepro; @@ -878,13 +876,10 @@ cmExportFileGenerator cmMakefile* mf = target->Makefile; // Add the soname for unix shared libraries. - if(target->GetType() == cmTarget::SHARED_LIBRARY || - target->GetType() == cmTarget::MODULE_LIBRARY) + if(target->GetType() == cmState::SHARED_LIBRARY || + target->GetType() == cmState::MODULE_LIBRARY) { - // Check whether this is a DLL platform. - bool dll_platform = - (mf->IsOn("WIN32") || mf->IsOn("CYGWIN") || mf->IsOn("MINGW")); - if(!dll_platform) + if(!target->IsDLLPlatform()) { std::string prop; std::string value; @@ -909,7 +904,7 @@ cmExportFileGenerator // Add the transitive link dependencies for this configuration. if(cmLinkInterface const* iface = - target->GetLinkInterface(config, target->Target)) + target->GetLinkInterface(config, target)) { this->SetImportLinkProperty(suffix, target, "IMPORTED_LINK_INTERFACE_LANGUAGES", @@ -959,7 +954,7 @@ cmExportFileGenerator sep = ";"; std::string temp = *li; - this->AddTargetNamespace(temp, target->Target, missingTargets); + this->AddTargetNamespace(temp, target, missingTargets); link_entries += temp; } @@ -1041,7 +1036,7 @@ void cmExportFileGenerator::GenerateExpectedTargetsCode(std::ostream& os, //---------------------------------------------------------------------------- void cmExportFileGenerator -::GenerateImportTargetCode(std::ostream& os, cmTarget const* target) +::GenerateImportTargetCode(std::ostream& os, const cmGeneratorTarget* target) { // Construct the imported target name. std::string targetName = this->Namespace; @@ -1052,22 +1047,22 @@ cmExportFileGenerator os << "# Create imported target " << targetName << "\n"; switch(target->GetType()) { - case cmTarget::EXECUTABLE: + case cmState::EXECUTABLE: os << "add_executable(" << targetName << " IMPORTED)\n"; break; - case cmTarget::STATIC_LIBRARY: + case cmState::STATIC_LIBRARY: os << "add_library(" << targetName << " STATIC IMPORTED)\n"; break; - case cmTarget::SHARED_LIBRARY: + case cmState::SHARED_LIBRARY: os << "add_library(" << targetName << " SHARED IMPORTED)\n"; break; - case cmTarget::MODULE_LIBRARY: + case cmState::MODULE_LIBRARY: os << "add_library(" << targetName << " MODULE IMPORTED)\n"; break; - case cmTarget::UNKNOWN_LIBRARY: + case cmState::UNKNOWN_LIBRARY: os << "add_library(" << targetName << " UNKNOWN IMPORTED)\n"; break; - case cmTarget::INTERFACE_LIBRARY: + case cmState::INTERFACE_LIBRARY: os << "add_library(" << targetName << " INTERFACE IMPORTED)\n"; break; default: // should never happen @@ -1107,7 +1102,7 @@ cmExportFileGenerator void cmExportFileGenerator ::GenerateImportPropertyCode(std::ostream& os, const std::string& config, - cmTarget const* target, + cmGeneratorTarget const* target, ImportPropertyMap const& properties) { // Construct the imported target name. @@ -1227,7 +1222,7 @@ cmExportFileGenerator::GenerateImportedFileCheckLoop(std::ostream& os) //---------------------------------------------------------------------------- void cmExportFileGenerator -::GenerateImportedFileChecksCode(std::ostream& os, cmTarget* target, +::GenerateImportedFileChecksCode(std::ostream& os, cmGeneratorTarget* target, ImportPropertyMap const& properties, const std::set<std::string>& importedLocations) { diff --git a/Source/cmExportFileGenerator.h b/Source/cmExportFileGenerator.h index 44f779b..18f0b00 100644 --- a/Source/cmExportFileGenerator.h +++ b/Source/cmExportFileGenerator.h @@ -75,11 +75,13 @@ protected: const std::string& config = ""); void GenerateImportFooterCode(std::ostream& os); void GenerateImportVersionCode(std::ostream& os); - void GenerateImportTargetCode(std::ostream& os, cmTarget const* target); + void GenerateImportTargetCode(std::ostream& os, + cmGeneratorTarget const* target); void GenerateImportPropertyCode(std::ostream& os, const std::string& config, - cmTarget const* target, + cmGeneratorTarget const* target, ImportPropertyMap const& properties); - void GenerateImportedFileChecksCode(std::ostream& os, cmTarget* target, + void GenerateImportedFileChecksCode(std::ostream& os, + cmGeneratorTarget* target, ImportPropertyMap const& properties, const std::set<std::string>& importedLocations); void GenerateImportedFileCheckLoop(std::ostream& os); @@ -118,23 +120,24 @@ protected: * export set. */ virtual void HandleMissingTarget(std::string& link_libs, std::vector<std::string>& missingTargets, - cmMakefile* mf, - cmTarget* depender, - cmTarget* dependee) = 0; + cmGeneratorTarget* depender, + cmGeneratorTarget* dependee) = 0; void PopulateInterfaceProperty(const std::string&, - cmTarget *target, + cmGeneratorTarget *target, cmGeneratorExpression::PreprocessContext, ImportPropertyMap &properties, std::vector<std::string> &missingTargets); - bool PopulateInterfaceLinkLibrariesProperty(cmTarget *target, + bool PopulateInterfaceLinkLibrariesProperty(cmGeneratorTarget* target, cmGeneratorExpression::PreprocessContext, ImportPropertyMap &properties, std::vector<std::string> &missingTargets); - void PopulateInterfaceProperty(const std::string& propName, cmTarget *target, + void PopulateInterfaceProperty(const std::string& propName, + cmGeneratorTarget* target, ImportPropertyMap &properties); void PopulateCompatibleInterfaceProperties(cmGeneratorTarget *target, ImportPropertyMap &properties); - void GenerateInterfaceProperties(cmTarget const* target, std::ostream& os, + void GenerateInterfaceProperties(cmGeneratorTarget const* target, + std::ostream& os, const ImportPropertyMap &properties); void PopulateIncludeDirectoriesInterface( cmTargetExport *target, @@ -159,7 +162,7 @@ protected: }; void ResolveTargetsInGeneratorExpressions(std::string &input, - cmTarget* target, + cmGeneratorTarget* target, std::vector<std::string> &missingTargets, FreeTargetsReplace replace = NoReplaceFreeTargets); @@ -182,20 +185,20 @@ protected: bool AppendMode; // The set of targets included in the export. - std::set<cmTarget*> ExportedTargets; + std::set<cmGeneratorTarget*> ExportedTargets; private: void PopulateInterfaceProperty(const std::string&, const std::string&, - cmTarget *target, + cmGeneratorTarget* target, cmGeneratorExpression::PreprocessContext, ImportPropertyMap &properties, std::vector<std::string> &missingTargets); - bool AddTargetNamespace(std::string &input, cmTarget* target, + bool AddTargetNamespace(std::string &input, cmGeneratorTarget* target, std::vector<std::string> &missingTargets); void ResolveTargetsInGeneratorExpression(std::string &input, - cmTarget* target, + cmGeneratorTarget* target, std::vector<std::string> &missingTargets); virtual void ReplaceInstallPrefix(std::string &input); diff --git a/Source/cmExportInstallFileGenerator.cxx b/Source/cmExportInstallFileGenerator.cxx index 7ffab0c..b695904 100644 --- a/Source/cmExportInstallFileGenerator.cxx +++ b/Source/cmExportInstallFileGenerator.cxx @@ -48,7 +48,8 @@ bool cmExportInstallFileGenerator::GenerateMainFile(std::ostream& os) tei = this->IEGen->GetExportSet()->GetTargetExports()->begin(); tei != this->IEGen->GetExportSet()->GetTargetExports()->end(); ++tei) { - expectedTargets += sep + this->Namespace + (*tei)->Target->GetExportName(); + expectedTargets += + sep + this->Namespace + (*tei)->Target->GetExportName(); sep = " "; cmTargetExport * te = *tei; if(this->ExportedTargets.insert(te->Target).second) @@ -131,12 +132,12 @@ bool cmExportInstallFileGenerator::GenerateMainFile(std::ostream& os) tei = allTargets.begin(); tei != allTargets.end(); ++tei) { - cmTarget* te = (*tei)->Target; + cmGeneratorTarget* gt = (*tei)->Target; requiresConfigFiles = requiresConfigFiles - || te->GetType() != cmTarget::INTERFACE_LIBRARY; + || gt->GetType() != cmState::INTERFACE_LIBRARY; - this->GenerateImportTargetCode(os, te); + this->GenerateImportTargetCode(os, gt); ImportPropertyMap properties; @@ -147,32 +148,32 @@ bool cmExportInstallFileGenerator::GenerateMainFile(std::ostream& os) cmGeneratorExpression::InstallInterface, properties, missingTargets); this->PopulateInterfaceProperty("INTERFACE_SYSTEM_INCLUDE_DIRECTORIES", - te, + gt, cmGeneratorExpression::InstallInterface, properties, missingTargets); this->PopulateInterfaceProperty("INTERFACE_COMPILE_DEFINITIONS", - te, + gt, cmGeneratorExpression::InstallInterface, properties, missingTargets); this->PopulateInterfaceProperty("INTERFACE_COMPILE_OPTIONS", - te, + gt, cmGeneratorExpression::InstallInterface, properties, missingTargets); this->PopulateInterfaceProperty("INTERFACE_AUTOUIC_OPTIONS", - te, + gt, cmGeneratorExpression::InstallInterface, properties, missingTargets); this->PopulateInterfaceProperty("INTERFACE_COMPILE_FEATURES", - te, + gt, cmGeneratorExpression::InstallInterface, properties, missingTargets); const bool newCMP0022Behavior = - te->GetPolicyStatusCMP0022() != cmPolicies::WARN - && te->GetPolicyStatusCMP0022() != cmPolicies::OLD; + gt->GetPolicyStatusCMP0022() != cmPolicies::WARN + && gt->GetPolicyStatusCMP0022() != cmPolicies::OLD; if (newCMP0022Behavior) { - if (this->PopulateInterfaceLinkLibrariesProperty(te, + if (this->PopulateInterfaceLinkLibrariesProperty(gt, cmGeneratorExpression::InstallInterface, properties, missingTargets) && !this->ExportOld) @@ -180,11 +181,11 @@ bool cmExportInstallFileGenerator::GenerateMainFile(std::ostream& os) require2_8_12 = true; } } - if (te->GetType() == cmTarget::INTERFACE_LIBRARY) + if (gt->GetType() == cmState::INTERFACE_LIBRARY) { require3_0_0 = true; } - if(te->GetProperty("INTERFACE_SOURCES")) + if(gt->GetProperty("INTERFACE_SOURCES")) { // We can only generate INTERFACE_SOURCES in CMake 3.3, but CMake 3.1 // can consume them. @@ -192,14 +193,11 @@ bool cmExportInstallFileGenerator::GenerateMainFile(std::ostream& os) } this->PopulateInterfaceProperty("INTERFACE_POSITION_INDEPENDENT_CODE", - te, properties); - cmGeneratorTarget *gtgt = te->GetMakefile() - ->GetGlobalGenerator() - ->GetGeneratorTarget(te); + gt, properties); - this->PopulateCompatibleInterfaceProperties(gtgt, properties); + this->PopulateCompatibleInterfaceProperties(gt, properties); - this->GenerateInterfaceProperties(te, os, properties); + this->GenerateInterfaceProperties(gt, os, properties); } if (require3_1_0) @@ -337,7 +335,7 @@ cmExportInstallFileGenerator { // Collect import properties for this target. cmTargetExport const* te = *tei; - if (te->Target->GetType() == cmTarget::INTERFACE_LIBRARY) + if (te->Target->GetType() == cmState::INTERFACE_LIBRARY) { continue; } @@ -362,8 +360,7 @@ cmExportInstallFileGenerator if(!properties.empty()) { // Get the rest of the target details. - cmGeneratorTarget *gtgt = te->Target->GetMakefile() - ->GetGlobalGenerator()->GetGeneratorTarget(te->Target); + cmGeneratorTarget *gtgt = te->Target; this->SetImportDetailProperties(config, suffix, gtgt, properties, missingTargets); @@ -378,8 +375,8 @@ cmExportInstallFileGenerator // properties); // Generate code in the export file. - this->GenerateImportPropertyCode(os, config, te->Target, properties); - this->GenerateImportedFileChecksCode(os, te->Target, properties, + this->GenerateImportPropertyCode(os, config, gtgt, properties); + this->GenerateImportedFileChecksCode(os, gtgt, properties, importedLocations); } } @@ -402,7 +399,7 @@ cmExportInstallFileGenerator } // Get the target to be installed. - cmTarget* target = itgen->GetTarget()->Target; + cmGeneratorTarget* target = itgen->GetTarget(); // Construct the installed location of the target. std::string dest = itgen->GetDestination(config); @@ -456,12 +453,13 @@ cmExportInstallFileGenerator //---------------------------------------------------------------------------- void -cmExportInstallFileGenerator::HandleMissingTarget( - std::string& link_libs, std::vector<std::string>& missingTargets, - cmMakefile* mf, cmTarget* depender, cmTarget* dependee) +cmExportInstallFileGenerator::HandleMissingTarget(std::string& link_libs, + std::vector<std::string>& missingTargets, + cmGeneratorTarget* depender, cmGeneratorTarget* dependee) { const std::string name = dependee->GetName(); - std::vector<std::string> namespaces = this->FindNamespaces(mf, name); + cmGlobalGenerator* gg = dependee->GetLocalGenerator()->GetGlobalGenerator(); + std::vector<std::string> namespaces = this->FindNamespaces(gg, name); int targetOccurrences = (int)namespaces.size(); if (targetOccurrences == 1) { @@ -482,10 +480,9 @@ cmExportInstallFileGenerator::HandleMissingTarget( //---------------------------------------------------------------------------- std::vector<std::string> cmExportInstallFileGenerator -::FindNamespaces(cmMakefile* mf, const std::string& name) +::FindNamespaces(cmGlobalGenerator* gg, const std::string& name) { std::vector<std::string> namespaces; - cmGlobalGenerator* gg = mf->GetGlobalGenerator(); const cmExportSetMap& exportSets = gg->GetExportSets(); for(cmExportSetMap::const_iterator expIt = exportSets.begin(); @@ -523,8 +520,8 @@ cmExportInstallFileGenerator //---------------------------------------------------------------------------- void cmExportInstallFileGenerator -::ComplainAboutMissingTarget(cmTarget* depender, - cmTarget* dependee, +::ComplainAboutMissingTarget(cmGeneratorTarget* depender, + cmGeneratorTarget* dependee, int occurrences) { std::ostringstream e; diff --git a/Source/cmExportInstallFileGenerator.h b/Source/cmExportInstallFileGenerator.h index b06fee5..13dae89 100644 --- a/Source/cmExportInstallFileGenerator.h +++ b/Source/cmExportInstallFileGenerator.h @@ -57,17 +57,16 @@ protected: std::vector<std::string> &missingTargets); virtual void HandleMissingTarget(std::string& link_libs, std::vector<std::string>& missingTargets, - cmMakefile* mf, - cmTarget* depender, - cmTarget* dependee); + cmGeneratorTarget* depender, + cmGeneratorTarget* dependee); virtual void ReplaceInstallPrefix(std::string &input); - void ComplainAboutMissingTarget(cmTarget* depender, - cmTarget* dependee, + void ComplainAboutMissingTarget(cmGeneratorTarget* depender, + cmGeneratorTarget* dependee, int occurrences); - std::vector<std::string> FindNamespaces(cmMakefile* mf, + std::vector<std::string> FindNamespaces(cmGlobalGenerator* gg, const std::string& name); diff --git a/Source/cmExportLibraryDependenciesCommand.cxx b/Source/cmExportLibraryDependenciesCommand.cxx index fde8fb1..21d961f 100644 --- a/Source/cmExportLibraryDependenciesCommand.cxx +++ b/Source/cmExportLibraryDependenciesCommand.cxx @@ -96,8 +96,8 @@ void cmExportLibraryDependenciesCommand::ConstFinalPass() const cmTarget const& target = l->second; // Skip non-library targets. - if(target.GetType() < cmTarget::STATIC_LIBRARY - || target.GetType() > cmTarget::MODULE_LIBRARY) + if(target.GetType() < cmState::STATIC_LIBRARY + || target.GetType() > cmState::MODULE_LIBRARY) { continue; } @@ -120,15 +120,15 @@ void cmExportLibraryDependenciesCommand::ConstFinalPass() const std::string ltValue; switch(li->second) { - case cmTarget::GENERAL: + case GENERAL_LibraryType: valueNew += "general;"; ltValue = "general"; break; - case cmTarget::DEBUG: + case DEBUG_LibraryType: valueNew += "debug;"; ltValue = "debug"; break; - case cmTarget::OPTIMIZED: + case OPTIMIZED_LibraryType: valueNew += "optimized;"; ltValue = "optimized"; break; diff --git a/Source/cmExportSet.cxx b/Source/cmExportSet.cxx index 4148fb5..0059b64 100644 --- a/Source/cmExportSet.cxx +++ b/Source/cmExportSet.cxx @@ -13,12 +13,22 @@ #include "cmExportSet.h" #include "cmTargetExport.h" #include "cmAlgorithms.h" +#include "cmLocalGenerator.h" cmExportSet::~cmExportSet() { cmDeleteAll(this->TargetExports); } +void cmExportSet::Compute(cmLocalGenerator* lg) +{ + for (std::vector<cmTargetExport*>::iterator it = this->TargetExports.begin(); + it != this->TargetExports.end(); ++it) + { + (*it)->Target = lg->FindGeneratorTargetToUse((*it)->TargetName); + } +} + void cmExportSet::AddTargetExport(cmTargetExport* te) { this->TargetExports.push_back(te); diff --git a/Source/cmExportSet.h b/Source/cmExportSet.h index a57aa12..d780a22 100644 --- a/Source/cmExportSet.h +++ b/Source/cmExportSet.h @@ -15,6 +15,7 @@ #include "cmSystemTools.h" class cmTargetExport; class cmInstallExportGenerator; +class cmLocalGenerator; /// A set of targets that were installed with the same EXPORT parameter. class cmExportSet @@ -25,6 +26,8 @@ public: /// Destructor ~cmExportSet(); + void Compute(cmLocalGenerator* lg); + void AddTargetExport(cmTargetExport* tgt); void AddInstallation(cmInstallExportGenerator const* installation); diff --git a/Source/cmExportTryCompileFileGenerator.cxx b/Source/cmExportTryCompileFileGenerator.cxx index ba66531..83127e7 100644 --- a/Source/cmExportTryCompileFileGenerator.cxx +++ b/Source/cmExportTryCompileFileGenerator.cxx @@ -14,22 +14,25 @@ #include "cmGeneratedFileStream.h" #include "cmGlobalGenerator.h" +#include "cmLocalGenerator.h" #include "cmGeneratorExpressionDAGChecker.h" //---------------------------------------------------------------------------- cmExportTryCompileFileGenerator::cmExportTryCompileFileGenerator( - cmGlobalGenerator* gg) + cmGlobalGenerator* gg, + const std::vector<std::string>& targets, + cmMakefile* mf) { - gg->CreateGenerationObjects(cmGlobalGenerator::ImportedOnly); + gg->CreateImportedGenerationObjects(mf, targets, this->Exports); } bool cmExportTryCompileFileGenerator::GenerateMainFile(std::ostream& os) { - std::set<cmTarget const*> emitted; - std::set<cmTarget const*> emittedDeps; + std::set<cmGeneratorTarget const*> emitted; + std::set<cmGeneratorTarget const*> emittedDeps; while(!this->Exports.empty()) { - cmTarget const* te = this->Exports.back(); + cmGeneratorTarget const* te = this->Exports.back(); this->Exports.pop_back(); if (emitted.insert(te).second) { @@ -54,9 +57,9 @@ bool cmExportTryCompileFileGenerator::GenerateMainFile(std::ostream& os) } std::string cmExportTryCompileFileGenerator::FindTargets( - const std::string& propName, - cmTarget const* tgt, - std::set<cmTarget const*> &emitted) + const std::string& propName, + cmGeneratorTarget const* tgt, + std::set<cmGeneratorTarget const*> &emitted) { const char *prop = tgt->GetProperty(propName); if(!prop) @@ -73,15 +76,19 @@ std::string cmExportTryCompileFileGenerator::FindTargets( cmsys::auto_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(prop); cmTarget dummyHead; - dummyHead.SetType(cmTarget::EXECUTABLE, "try_compile_dummy_exe"); - dummyHead.SetMakefile(tgt->GetMakefile()); + dummyHead.SetType(cmState::EXECUTABLE, "try_compile_dummy_exe"); + dummyHead.SetMakefile(tgt->Target->GetMakefile()); - std::string result = cge->Evaluate(tgt->GetMakefile(), this->Config, - false, &dummyHead, tgt, &dagChecker); + cmGeneratorTarget gDummyHead(&dummyHead, tgt->GetLocalGenerator()); - const std::set<cmTarget const*> &allTargets = cge->GetAllTargetsSeen(); - for(std::set<cmTarget const*>::const_iterator li = allTargets.begin(); - li != allTargets.end(); ++li) + std::string result = cge->Evaluate(tgt->GetLocalGenerator(), this->Config, + false, &gDummyHead, + tgt, &dagChecker); + + const std::set<cmGeneratorTarget const*> &allTargets = + cge->GetAllTargetsSeen(); + for(std::set<cmGeneratorTarget const*>::const_iterator li = + allTargets.begin(); li != allTargets.end(); ++li) { if(emitted.insert(*li).second) { @@ -93,20 +100,23 @@ std::string cmExportTryCompileFileGenerator::FindTargets( //---------------------------------------------------------------------------- void -cmExportTryCompileFileGenerator::PopulateProperties(cmTarget const* target, - ImportPropertyMap& properties, - std::set<cmTarget const*> &emitted) +cmExportTryCompileFileGenerator::PopulateProperties( + const cmGeneratorTarget* target, + ImportPropertyMap& properties, + std::set<cmGeneratorTarget const*> &emitted) { - cmPropertyMap props = target->GetProperties(); - for(cmPropertyMap::const_iterator i = props.begin(); i != props.end(); ++i) + std::vector<std::string> props = target->GetPropertyKeys(); + for(std::vector<std::string>::const_iterator i = props.begin(); + i != props.end(); ++i) { - properties[i->first] = i->second.GetValue(); - if(i->first.find("IMPORTED_LINK_INTERFACE_LIBRARIES") == 0 - || i->first.find("IMPORTED_LINK_DEPENDENT_LIBRARIES") == 0 - || i->first.find("INTERFACE_LINK_LIBRARIES") == 0) + properties[*i] = target->GetProperty(*i); + + if(i->find("IMPORTED_LINK_INTERFACE_LIBRARIES") == 0 + || i->find("IMPORTED_LINK_DEPENDENT_LIBRARIES") == 0 + || i->find("INTERFACE_LINK_LIBRARIES") == 0) { - std::string evalResult = this->FindTargets(i->first, + std::string evalResult = this->FindTargets(*i, target, emitted); std::vector<std::string> depends; @@ -114,7 +124,8 @@ cmExportTryCompileFileGenerator::PopulateProperties(cmTarget const* target, for(std::vector<std::string>::const_iterator li = depends.begin(); li != depends.end(); ++li) { - cmTarget *tgt = target->GetMakefile()->FindTargetToUse(*li); + cmGeneratorTarget *tgt = + target->GetLocalGenerator()->FindGeneratorTargetToUse(*li); if(tgt && emitted.insert(tgt).second) { this->Exports.push_back(tgt); diff --git a/Source/cmExportTryCompileFileGenerator.h b/Source/cmExportTryCompileFileGenerator.h index 8838eca..fc135a4 100644 --- a/Source/cmExportTryCompileFileGenerator.h +++ b/Source/cmExportTryCompileFileGenerator.h @@ -20,11 +20,11 @@ class cmInstallTargetGenerator; class cmExportTryCompileFileGenerator: public cmExportFileGenerator { public: - cmExportTryCompileFileGenerator(cmGlobalGenerator* gg); + cmExportTryCompileFileGenerator(cmGlobalGenerator* gg, + std::vector<std::string> const& targets, + cmMakefile* mf); /** Set the list of targets to export. */ - void SetExports(const std::vector<cmTarget const*> &exports) - { this->Exports = exports; } void SetConfig(const std::string& config) { this->Config = config; } protected: @@ -37,22 +37,22 @@ protected: std::vector<std::string>&) {} virtual void HandleMissingTarget(std::string&, std::vector<std::string>&, - cmMakefile*, - cmTarget*, - cmTarget*) {} + cmGeneratorTarget*, + cmGeneratorTarget*) {} - void PopulateProperties(cmTarget const* target, + void PopulateProperties(cmGeneratorTarget const* target, ImportPropertyMap& properties, - std::set<cmTarget const*> &emitted); + std::set<const cmGeneratorTarget*>& emitted); std::string InstallNameDir(cmGeneratorTarget* target, const std::string& config); private: - std::string FindTargets(const std::string& prop, cmTarget const* tgt, - std::set<cmTarget const*> &emitted); + std::string FindTargets(const std::string& prop, + const cmGeneratorTarget* tgt, + std::set<const cmGeneratorTarget*>& emitted); - std::vector<cmTarget const*> Exports; + std::vector<cmGeneratorTarget const*> Exports; std::string Config; }; diff --git a/Source/cmExtraCodeBlocksGenerator.cxx b/Source/cmExtraCodeBlocksGenerator.cxx index dfd51c7..9348ef2 100644 --- a/Source/cmExtraCodeBlocksGenerator.cxx +++ b/Source/cmExtraCodeBlocksGenerator.cxx @@ -17,7 +17,6 @@ #include "cmake.h" #include "cmSourceFile.h" #include "cmGeneratedFileStream.h" -#include "cmTarget.h" #include "cmSystemTools.h" #include "cmXMLSafe.h" @@ -76,9 +75,8 @@ void cmExtraCodeBlocksGenerator::Generate() void cmExtraCodeBlocksGenerator::CreateProjectFile( const std::vector<cmLocalGenerator*>& lgs) { - const cmMakefile* mf=lgs[0]->GetMakefile(); - std::string outputDir=mf->GetCurrentBinaryDirectory(); - std::string projectName=mf->GetProjectName(); + std::string outputDir=lgs[0]->GetCurrentBinaryDirectory(); + std::string projectName=lgs[0]->GetProjectName(); std::string filename=outputDir+"/"; filename+=projectName+".cbp"; @@ -273,7 +271,7 @@ void cmExtraCodeBlocksGenerator } const std::string &relative = cmSystemTools::RelativePath( - it->second[0]->GetMakefile()->GetHomeDirectory(), + it->second[0]->GetSourceDirectory(), jt->c_str()); std::vector<std::string> splitted; cmSystemTools::SplitPath(relative, splitted, false); @@ -297,7 +295,7 @@ void cmExtraCodeBlocksGenerator tree.BuildVirtualFolder(virtualFolders); // And one for <Unit> std::string unitFiles; - tree.BuildUnit(unitFiles, std::string(mf->GetHomeDirectory()) + "/"); + tree.BuildUnit(unitFiles, std::string(lgs[0]->GetSourceDirectory()) + "/"); // figure out the compiler std::string compiler = this->GetCBCompilerId(mf); @@ -307,7 +305,7 @@ void cmExtraCodeBlocksGenerator "<CodeBlocks_project_file>\n" " <FileVersion major=\"1\" minor=\"6\" />\n" " <Project>\n" - " <Option title=\"" << mf->GetProjectName()<<"\" />\n" + " <Option title=\"" << lgs[0]->GetProjectName()<<"\" />\n" " <Option makefile_is_custom=\"1\" />\n" " <Option compiler=\"" << compiler << "\" />\n" " "<<virtualFolders<<"\n" @@ -320,50 +318,52 @@ void cmExtraCodeBlocksGenerator for (std::vector<cmLocalGenerator*>::const_iterator lg=lgs.begin(); lg!=lgs.end(); lg++) { - cmMakefile* makefile=(*lg)->GetMakefile(); - cmTargets& targets=makefile->GetTargets(); - for (cmTargets::iterator ti = targets.begin(); + std::vector<cmGeneratorTarget*> targets=(*lg)->GetGeneratorTargets(); + for (std::vector<cmGeneratorTarget*>::iterator ti = targets.begin(); ti != targets.end(); ti++) { - switch(ti->second.GetType()) + std::string targetName = (*ti)->GetName(); + switch((*ti)->GetType()) { - case cmTarget::GLOBAL_TARGET: + case cmState::GLOBAL_TARGET: { // Only add the global targets from CMAKE_BINARY_DIR, // not from the subdirs - if (strcmp(makefile->GetCurrentBinaryDirectory(), - makefile->GetHomeOutputDirectory())==0) + if (strcmp((*lg)->GetCurrentBinaryDirectory(), + (*lg)->GetBinaryDirectory())==0) { - this->AppendTarget(fout, ti->first, 0, + this->AppendTarget(fout, targetName, 0, make.c_str(), *lg, compiler.c_str()); } } break; - case cmTarget::UTILITY: + case cmState::UTILITY: // Add all utility targets, except the Nightly/Continuous/ // Experimental-"sub"targets as e.g. NightlyStart - if (((ti->first.find("Nightly")==0) &&(ti->first!="Nightly")) - || ((ti->first.find("Continuous")==0)&&(ti->first!="Continuous")) - || ((ti->first.find("Experimental")==0) - && (ti->first!="Experimental"))) + if (((targetName.find("Nightly")==0) &&(targetName!="Nightly")) + || ((targetName.find("Continuous")==0) + &&(targetName!="Continuous")) + || ((targetName.find("Experimental")==0) + && (targetName!="Experimental"))) { break; } - this->AppendTarget(fout, ti->first, 0, + this->AppendTarget(fout, targetName, 0, make.c_str(), *lg, compiler.c_str()); break; - case cmTarget::EXECUTABLE: - case cmTarget::STATIC_LIBRARY: - case cmTarget::SHARED_LIBRARY: - case cmTarget::MODULE_LIBRARY: - case cmTarget::OBJECT_LIBRARY: + case cmState::EXECUTABLE: + case cmState::STATIC_LIBRARY: + case cmState::SHARED_LIBRARY: + case cmState::MODULE_LIBRARY: + case cmState::OBJECT_LIBRARY: { - this->AppendTarget(fout, ti->first, &ti->second, + cmGeneratorTarget* gt = *ti; + this->AppendTarget(fout, targetName, gt, make.c_str(), *lg, compiler.c_str()); - std::string fastTarget = ti->first; + std::string fastTarget = targetName; fastTarget += "/fast"; - this->AppendTarget(fout, fastTarget, &ti->second, + this->AppendTarget(fout, fastTarget, gt, make.c_str(), *lg, compiler.c_str()); } break; @@ -383,25 +383,29 @@ void cmExtraCodeBlocksGenerator all_files_map_t allFiles; std::vector<std::string> cFiles; + std::vector<std::string> srcExts = + this->GlobalGenerator->GetCMakeInstance()->GetSourceExtensions(); + for (std::vector<cmLocalGenerator*>::const_iterator lg=lgs.begin(); lg!=lgs.end(); lg++) { cmMakefile* makefile=(*lg)->GetMakefile(); - cmTargets& targets=makefile->GetTargets(); - for (cmTargets::iterator ti = targets.begin(); + std::vector<cmGeneratorTarget*> targets=(*lg)->GetGeneratorTargets(); + for (std::vector<cmGeneratorTarget*>::iterator ti = targets.begin(); ti != targets.end(); ti++) { - switch(ti->second.GetType()) + switch((*ti)->GetType()) { - case cmTarget::EXECUTABLE: - case cmTarget::STATIC_LIBRARY: - case cmTarget::SHARED_LIBRARY: - case cmTarget::MODULE_LIBRARY: - case cmTarget::OBJECT_LIBRARY: - case cmTarget::UTILITY: // can have sources since 2.6.3 + case cmState::EXECUTABLE: + case cmState::STATIC_LIBRARY: + case cmState::SHARED_LIBRARY: + case cmState::MODULE_LIBRARY: + case cmState::OBJECT_LIBRARY: + case cmState::UTILITY: // can have sources since 2.6.3 { std::vector<cmSourceFile*> sources; - ti->second.GetSourceFiles(sources, + cmGeneratorTarget* gt = *ti; + gt->GetSourceFiles(sources, makefile->GetSafeDefinition("CMAKE_BUILD_TYPE")); for (std::vector<cmSourceFile*>::const_iterator si=sources.begin(); si!=sources.end(); si++) @@ -419,9 +423,7 @@ void cmExtraCodeBlocksGenerator { std::string srcext = (*si)->GetExtension(); for(std::vector<std::string>::const_iterator - ext = mf->GetSourceExtensions().begin(); - ext != mf->GetSourceExtensions().end(); - ++ext) + ext = srcExts.begin(); ext != srcExts.end(); ++ext) { if (srcext == *ext) { @@ -439,7 +441,7 @@ void cmExtraCodeBlocksGenerator } CbpUnit &cbpUnit = allFiles[fullPath]; - cbpUnit.Targets.push_back(&(ti->second)); + cbpUnit.Targets.push_back(*ti); } } default: // intended fallthrough @@ -448,6 +450,9 @@ void cmExtraCodeBlocksGenerator } } + std::vector<std::string> headerExts = + this->GlobalGenerator->GetCMakeInstance()->GetHeaderExtensions(); + // The following loop tries to add header files matching to implementation // files to the project. It does that by iterating over all // C/C++ source files, @@ -467,8 +472,8 @@ void cmExtraCodeBlocksGenerator // check if there's a matching header around for(std::vector<std::string>::const_iterator - ext = mf->GetHeaderExtensions().begin(); - ext != mf->GetHeaderExtensions().end(); + ext = headerExts.begin(); + ext != headerExts.end(); ++ext) { std::string hname=headerBasename; @@ -499,8 +504,9 @@ void cmExtraCodeBlocksGenerator fout<<" <Unit filename=\""<< cmXMLSafe(unitFilename) <<"\">\n"; - for(std::vector<const cmTarget*>::const_iterator ti = unit.Targets.begin(); - ti != unit.Targets.end(); ++ti) + for(std::vector<const cmGeneratorTarget*>::const_iterator ti = + unit.Targets.begin(); + ti != unit.Targets.end(); ++ti) { std::string const& targetName = (*ti)->GetName(); fout<<" <Option target=\""<< cmXMLSafe(targetName) <<"\"/>\n"; @@ -520,15 +526,14 @@ void cmExtraCodeBlocksGenerator // Write a dummy file for OBJECT libraries, so C::B can reference some file std::string cmExtraCodeBlocksGenerator::CreateDummyTargetFile( cmLocalGenerator* lg, - cmTarget* target) const + cmGeneratorTarget* target) const { - cmMakefile *mf = lg->GetMakefile(); // this file doesn't seem to be used by C::B in custom makefile mode, // but we generate a unique file for each OBJECT library so in case // C::B uses it in some way, the targets don't interfere with each other. - std::string filename = mf->GetCurrentBinaryDirectory(); + std::string filename = lg->GetCurrentBinaryDirectory(); filename += "/"; - filename += lg->GetTargetDirectory(*target); + filename += lg->GetTargetDirectory(target); filename += "/"; filename += target->GetName(); filename += ".objlib"; @@ -547,21 +552,21 @@ std::string cmExtraCodeBlocksGenerator::CreateDummyTargetFile( // Generate the xml code for one target. void cmExtraCodeBlocksGenerator::AppendTarget(cmGeneratedFileStream& fout, const std::string& targetName, - cmTarget* target, + cmGeneratorTarget* target, const char* make, const cmLocalGenerator* lg, const char* compiler) { cmMakefile const* makefile = lg->GetMakefile(); - std::string makefileName = makefile->GetCurrentBinaryDirectory(); + std::string makefileName = lg->GetCurrentBinaryDirectory(); makefileName += "/Makefile"; fout<<" <Target title=\"" << targetName << "\">\n"; if (target!=0) { int cbTargetType = this->GetCBTargetType(target); - std::string workingDir = makefile->GetCurrentBinaryDirectory(); - if ( target->GetType()==cmTarget::EXECUTABLE) + std::string workingDir = lg->GetCurrentBinaryDirectory(); + if ( target->GetType()==cmState::EXECUTABLE) { // Determine the directory where the executable target is created, and // set the working directory to this dir. @@ -584,16 +589,14 @@ void cmExtraCodeBlocksGenerator::AppendTarget(cmGeneratedFileStream& fout, std::string buildType = makefile->GetSafeDefinition("CMAKE_BUILD_TYPE"); std::string location; - if ( target->GetType()==cmTarget::OBJECT_LIBRARY) + if ( target->GetType()==cmState::OBJECT_LIBRARY) { location = this->CreateDummyTargetFile(const_cast<cmLocalGenerator*>(lg), target); } else { - cmGeneratorTarget* gt = - this->GlobalGenerator->GetGeneratorTarget(target); - location = gt->GetLocation(buildType); + location = target->GetLocation(buildType); } fout<<" <Option output=\"" << location @@ -604,12 +607,9 @@ void cmExtraCodeBlocksGenerator::AppendTarget(cmGeneratedFileStream& fout, " <Option compiler=\"" << compiler << "\" />\n" " <Compiler>\n"; - cmGeneratorTarget *gtgt = this->GlobalGenerator - ->GetGeneratorTarget(target); - // the compilerdefines for this target std::vector<std::string> cdefs; - gtgt->GetCompileDefinitions(cdefs, buildType, "C"); + target->GetCompileDefinitions(cdefs, buildType, "C"); // Expand the list. for(std::vector<std::string>::const_iterator di = cdefs.begin(); @@ -623,7 +623,7 @@ void cmExtraCodeBlocksGenerator::AppendTarget(cmGeneratedFileStream& fout, std::set<std::string> uniqIncludeDirs; std::vector<std::string> includes; - lg->GetIncludeDirectories(includes, gtgt, "C", buildType); + lg->GetIncludeDirectories(includes, target, "C", buildType); uniqIncludeDirs.insert(includes.begin(), includes.end()); @@ -657,7 +657,7 @@ void cmExtraCodeBlocksGenerator::AppendTarget(cmGeneratedFileStream& fout, else // e.g. all and the GLOBAL and UTILITY targets { fout<<" <Option working_dir=\"" - << makefile->GetCurrentBinaryDirectory() << "\" />\n" + << lg->GetCurrentBinaryDirectory() << "\" />\n" <<" <Option type=\"" << 4 << "\" />\n"; } @@ -691,8 +691,6 @@ std::string cmExtraCodeBlocksGenerator::GetCBCompilerId(const cmMakefile* mf) compilerIdVar = "CMAKE_C_COMPILER_ID"; } - std::string hostSystemName = mf->GetSafeDefinition("CMAKE_HOST_SYSTEM_NAME"); - std::string systemName = mf->GetSafeDefinition("CMAKE_SYSTEM_NAME"); std::string compilerId = mf->GetSafeDefinition(compilerIdVar); std::string compiler = "gcc"; // default to gcc if (compilerId == "MSVC") @@ -724,9 +722,9 @@ std::string cmExtraCodeBlocksGenerator::GetCBCompilerId(const cmMakefile* mf) // Translate the cmake target type into the CodeBlocks target type id -int cmExtraCodeBlocksGenerator::GetCBTargetType(cmTarget* target) +int cmExtraCodeBlocksGenerator::GetCBTargetType(cmGeneratorTarget* target) { - if ( target->GetType()==cmTarget::EXECUTABLE) + if ( target->GetType()==cmState::EXECUTABLE) { if ((target->GetPropertyAsBool("WIN32_EXECUTABLE")) || (target->GetPropertyAsBool("MACOSX_BUNDLE"))) @@ -738,13 +736,13 @@ int cmExtraCodeBlocksGenerator::GetCBTargetType(cmTarget* target) return 1; } } - else if (( target->GetType()==cmTarget::STATIC_LIBRARY) - || (target->GetType()==cmTarget::OBJECT_LIBRARY)) + else if (( target->GetType()==cmState::STATIC_LIBRARY) + || (target->GetType()==cmState::OBJECT_LIBRARY)) { return 2; } - else if ((target->GetType()==cmTarget::SHARED_LIBRARY) - || (target->GetType()==cmTarget::MODULE_LIBRARY)) + else if ((target->GetType()==cmState::SHARED_LIBRARY) + || (target->GetType()==cmState::MODULE_LIBRARY)) { return 3; } diff --git a/Source/cmExtraCodeBlocksGenerator.h b/Source/cmExtraCodeBlocksGenerator.h index e5ede9a..0c3846d 100644 --- a/Source/cmExtraCodeBlocksGenerator.h +++ b/Source/cmExtraCodeBlocksGenerator.h @@ -17,7 +17,7 @@ class cmLocalGenerator; class cmMakefile; -class cmTarget; +class cmGeneratorTarget; class cmGeneratedFileStream; /** \class cmExtraCodeBlocksGenerator @@ -41,7 +41,7 @@ public: private: struct CbpUnit { - std::vector<const cmTarget*> Targets; + std::vector<const cmGeneratorTarget*> Targets; }; void CreateProjectFile(const std::vector<cmLocalGenerator*>& lgs); @@ -49,15 +49,15 @@ private: void CreateNewProjectFile(const std::vector<cmLocalGenerator*>& lgs, const std::string& filename); std::string CreateDummyTargetFile(cmLocalGenerator* lg, - cmTarget* target) const; + cmGeneratorTarget* target) const; std::string GetCBCompilerId(const cmMakefile* mf); - int GetCBTargetType(cmTarget* target); + int GetCBTargetType(cmGeneratorTarget* target); std::string BuildMakeCommand(const std::string& make, const char* makefile, const std::string& target); void AppendTarget(cmGeneratedFileStream& fout, const std::string& targetName, - cmTarget* target, + cmGeneratorTarget* target, const char* make, const cmLocalGenerator* lg, const char* compiler); diff --git a/Source/cmExtraCodeLiteGenerator.cxx b/Source/cmExtraCodeLiteGenerator.cxx index c2cff14..67aa157 100644 --- a/Source/cmExtraCodeLiteGenerator.cxx +++ b/Source/cmExtraCodeLiteGenerator.cxx @@ -68,15 +68,15 @@ void cmExtraCodeLiteGenerator::Generate() const cmMakefile* mf =it->second[0]->GetMakefile(); this->ConfigName = GetConfigurationName( mf ); - if (strcmp(mf->GetCurrentBinaryDirectory(), - mf->GetHomeOutputDirectory()) == 0) + if (strcmp(it->second[0]->GetCurrentBinaryDirectory(), + it->second[0]->GetBinaryDirectory()) == 0) { - workspaceOutputDir = mf->GetCurrentBinaryDirectory(); - workspaceProjectName = mf->GetProjectName(); - workspaceSourcePath = mf->GetHomeDirectory(); + workspaceOutputDir = it->second[0]->GetCurrentBinaryDirectory(); + workspaceProjectName = it->second[0]->GetProjectName(); + workspaceSourcePath = it->second[0]->GetSourceDirectory(); workspaceFileName = workspaceOutputDir+"/"; workspaceFileName += workspaceProjectName + ".workspace"; - this->WorkspacePath = mf->GetCurrentBinaryDirectory();; + this->WorkspacePath = it->second[0]->GetCurrentBinaryDirectory();; fout.Open(workspaceFileName.c_str(), false, false); fout << "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n" @@ -91,9 +91,8 @@ void cmExtraCodeLiteGenerator::Generate() ++it) { // retrive project information - const cmMakefile* mf = it->second[0]->GetMakefile(); - std::string outputDir = mf->GetCurrentBinaryDirectory(); - std::string projectName = mf->GetProjectName(); + std::string outputDir = it->second[0]->GetCurrentBinaryDirectory(); + std::string projectName = it->second[0]->GetProjectName(); std::string filename = outputDir + "/" + projectName + ".project"; // Make the project file relative to the workspace @@ -121,9 +120,8 @@ void cmExtraCodeLiteGenerator::Generate() void cmExtraCodeLiteGenerator::CreateProjectFile( const std::vector<cmLocalGenerator*>& lgs) { - const cmMakefile* mf = lgs[0]->GetMakefile(); - std::string outputDir = mf->GetCurrentBinaryDirectory(); - std::string projectName = mf->GetProjectName(); + std::string outputDir = lgs[0]->GetCurrentBinaryDirectory(); + std::string projectName = lgs[0]->GetProjectName(); std::string filename = outputDir + "/"; filename += projectName + ".project"; @@ -143,7 +141,7 @@ void cmExtraCodeLiteGenerator //////////////////////////////////// fout << "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n" - "<CodeLite_Project Name=\"" << mf->GetProjectName() + "<CodeLite_Project Name=\"" << lgs[0]->GetProjectName() << "\" InternalType=\"\">\n"; // Collect all used source files in the project @@ -151,35 +149,40 @@ void cmExtraCodeLiteGenerator // which may have an acompanying header, one for all other files std::string projectType; + std::vector<std::string> srcExts = + this->GlobalGenerator->GetCMakeInstance()->GetSourceExtensions(); + std::vector<std::string> headerExts = + this->GlobalGenerator->GetCMakeInstance()->GetHeaderExtensions(); + std::map<std::string, cmSourceFile*> cFiles; std::set<std::string> otherFiles; for (std::vector<cmLocalGenerator*>::const_iterator lg=lgs.begin(); lg!=lgs.end(); lg++) { cmMakefile* makefile=(*lg)->GetMakefile(); - cmTargets& targets=makefile->GetTargets(); - for (cmTargets::iterator ti = targets.begin(); + std::vector<cmGeneratorTarget*> targets=(*lg)->GetGeneratorTargets(); + for (std::vector<cmGeneratorTarget*>::iterator ti = targets.begin(); ti != targets.end(); ti++) { - switch(ti->second.GetType()) + switch((*ti)->GetType()) { - case cmTarget::EXECUTABLE: + case cmState::EXECUTABLE: { projectType = "Executable"; } break; - case cmTarget::STATIC_LIBRARY: + case cmState::STATIC_LIBRARY: { projectType = "Static Library"; } break; - case cmTarget::SHARED_LIBRARY: + case cmState::SHARED_LIBRARY: { projectType = "Dynamic Library"; } break; - case cmTarget::MODULE_LIBRARY: + case cmState::MODULE_LIBRARY: { projectType = "Dynamic Library"; } @@ -188,15 +191,16 @@ void cmExtraCodeLiteGenerator break; } - switch(ti->second.GetType()) + switch((*ti)->GetType()) { - case cmTarget::EXECUTABLE: - case cmTarget::STATIC_LIBRARY: - case cmTarget::SHARED_LIBRARY: - case cmTarget::MODULE_LIBRARY: + case cmState::EXECUTABLE: + case cmState::STATIC_LIBRARY: + case cmState::SHARED_LIBRARY: + case cmState::MODULE_LIBRARY: { std::vector<cmSourceFile*> sources; - ti->second.GetSourceFiles(sources, + cmGeneratorTarget* gt = *ti; + gt->GetSourceFiles(sources, makefile->GetSafeDefinition("CMAKE_BUILD_TYPE")); for (std::vector<cmSourceFile*>::const_iterator si=sources.begin(); si!=sources.end(); si++) @@ -208,9 +212,7 @@ void cmExtraCodeLiteGenerator { std::string srcext = (*si)->GetExtension(); for(std::vector<std::string>::const_iterator - ext = mf->GetSourceExtensions().begin(); - ext != mf->GetSourceExtensions().end(); - ++ext) + ext = srcExts.begin(); ext != srcExts.end(); ++ext) { if (srcext == *ext) { @@ -254,8 +256,8 @@ void cmExtraCodeLiteGenerator // check if there's a matching header around for(std::vector<std::string>::const_iterator - ext = mf->GetHeaderExtensions().begin(); - ext != mf->GetHeaderExtensions().end(); + ext = headerExts.begin(); + ext != headerExts.end(); ++ext) { std::string hname=headerBasename; diff --git a/Source/cmExtraEclipseCDT4Generator.cxx b/Source/cmExtraEclipseCDT4Generator.cxx index 44bf586..aedf6f4 100644 --- a/Source/cmExtraEclipseCDT4Generator.cxx +++ b/Source/cmExtraEclipseCDT4Generator.cxx @@ -79,8 +79,8 @@ void cmExtraEclipseCDT4Generator //---------------------------------------------------------------------------- void cmExtraEclipseCDT4Generator::Generate() { - const cmMakefile* mf - = this->GlobalGenerator->GetLocalGenerators()[0]->GetMakefile(); + cmLocalGenerator* lg = this->GlobalGenerator->GetLocalGenerators()[0]; + const cmMakefile* mf = lg->GetMakefile(); std::string eclipseVersion = mf->GetSafeDefinition("CMAKE_ECLIPSE_VERSION"); cmsys::RegularExpression regex(".*([0-9]+\\.[0-9]+).*"); @@ -106,8 +106,8 @@ void cmExtraEclipseCDT4Generator::Generate() } // TODO: Decide if these are local or member variables - this->HomeDirectory = mf->GetHomeDirectory(); - this->HomeOutputDirectory = mf->GetHomeOutputDirectory(); + this->HomeDirectory = lg->GetSourceDirectory(); + this->HomeOutputDirectory = lg->GetBinaryDirectory(); this->GenerateLinkedResources = mf->IsOn( "CMAKE_ECLIPSE_GENERATE_LINKED_RESOURCES"); @@ -157,9 +157,8 @@ void cmExtraEclipseCDT4Generator::CreateSourceProjectFile() assert(this->HomeDirectory != this->HomeOutputDirectory); // set up the project name: <project>-Source@<baseSourcePathName> - const cmMakefile* mf - = this->GlobalGenerator->GetLocalGenerators()[0]->GetMakefile(); - std::string name = this->GenerateProjectName(mf->GetProjectName(), "Source", + cmLocalGenerator* lg = this->GlobalGenerator->GetLocalGenerators()[0]; + std::string name = this->GenerateProjectName(lg->GetProjectName(), "Source", this->GetPathBasename(this->HomeDirectory)); const std::string filename = this->HomeDirectory + "/.project"; @@ -197,8 +196,11 @@ void cmExtraEclipseCDT4Generator::CreateSourceProjectFile() //---------------------------------------------------------------------------- void cmExtraEclipseCDT4Generator::AddEnvVar(cmGeneratedFileStream& fout, - const char* envVar, cmMakefile* mf) + const char* envVar, + cmLocalGenerator* lg) { + cmMakefile* mf = lg->GetMakefile(); + // get the variables from the environment and from the cache and then // figure out which one to use: @@ -206,7 +208,7 @@ void cmExtraEclipseCDT4Generator::AddEnvVar(cmGeneratedFileStream& fout, std::string cacheEntryName = "CMAKE_ECLIPSE_ENVVAR_"; cacheEntryName += envVar; - const char* cacheValue = mf->GetState()->GetInitializedCacheValue( + const char* cacheValue = lg->GetState()->GetInitializedCacheValue( cacheEntryName); // now we have both, decide which one to use @@ -224,7 +226,7 @@ void cmExtraEclipseCDT4Generator::AddEnvVar(cmGeneratedFileStream& fout, mf->AddCacheDefinition(cacheEntryName, valueToUse.c_str(), cacheEntryName.c_str(), cmState::STRING, true); - mf->GetCMakeInstance()->SaveCache(mf->GetHomeOutputDirectory()); + mf->GetCMakeInstance()->SaveCache(lg->GetBinaryDirectory()); } else if (envVarValue==0 && cacheValue!=0) { @@ -245,7 +247,7 @@ void cmExtraEclipseCDT4Generator::AddEnvVar(cmGeneratedFileStream& fout, mf->AddCacheDefinition(cacheEntryName, valueToUse.c_str(), cacheEntryName.c_str(), cmState::STRING, true); - mf->GetCMakeInstance()->SaveCache(mf->GetHomeOutputDirectory()); + mf->GetCMakeInstance()->SaveCache(lg->GetBinaryDirectory()); } } @@ -259,8 +261,8 @@ void cmExtraEclipseCDT4Generator::AddEnvVar(cmGeneratedFileStream& fout, //---------------------------------------------------------------------------- void cmExtraEclipseCDT4Generator::CreateProjectFile() { - cmMakefile* mf - = this->GlobalGenerator->GetLocalGenerators()[0]->GetMakefile(); + cmLocalGenerator* lg = this->GlobalGenerator->GetLocalGenerators()[0]; + cmMakefile* mf = lg->GetMakefile(); const std::string filename = this->HomeOutputDirectory + "/.project"; @@ -280,7 +282,7 @@ void cmExtraEclipseCDT4Generator::CreateProjectFile() "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" "<projectDescription>\n" "\t<name>" << - this->GenerateProjectName(mf->GetProjectName(), + this->GenerateProjectName(lg->GetProjectName(), mf->GetSafeDefinition("CMAKE_BUILD_TYPE"), this->GetPathBasename(this->HomeOutputDirectory)) << "</name>\n" @@ -361,17 +363,17 @@ void cmExtraEclipseCDT4Generator::CreateProjectFile() // but not necessarily when eclipse is open if (compilerId == "MSVC") { - AddEnvVar(fout, "PATH", mf); - AddEnvVar(fout, "INCLUDE", mf); - AddEnvVar(fout, "LIB", mf); - AddEnvVar(fout, "LIBPATH", mf); + AddEnvVar(fout, "PATH", lg); + AddEnvVar(fout, "INCLUDE", lg); + AddEnvVar(fout, "LIB", lg); + AddEnvVar(fout, "LIBPATH", lg); } else if (compilerId == "Intel") { // if the env.var is set, use this one and put it in the cache // if the env.var is not set, but the value is in the cache, // use it from the cache: - AddEnvVar(fout, "INTEL_LICENSE_FILE", mf); + AddEnvVar(fout, "INTEL_LICENSE_FILE", lg); } fout << "</value>\n" @@ -495,7 +497,7 @@ void cmExtraEclipseCDT4Generator::CreateProjectFile() std::string sourceLinkedResourceName = "[Source directory]"; std::string linkSourceDirectory = this->GetEclipsePath( - mf->GetCurrentSourceDirectory()); + lg->GetCurrentSourceDirectory()); // .project dir can't be subdir of a linked resource dir if (!cmSystemTools::IsSubDirectory(this->HomeOutputDirectory, linkSourceDirectory)) @@ -534,24 +536,26 @@ void cmExtraEclipseCDT4Generator::CreateLinksForTargets( ++lgIt) { cmMakefile* makefile = (*lgIt)->GetMakefile(); - const cmTargets& targets = makefile->GetTargets(); + const std::vector<cmGeneratorTarget*> targets = + (*lgIt)->GetGeneratorTargets(); - for(cmTargets::const_iterator ti=targets.begin(); ti!=targets.end();++ti) + for(std::vector<cmGeneratorTarget*>::const_iterator ti=targets.begin(); + ti!=targets.end();++ti) { std::string linkName2 = linkName; linkName2 += "/"; - switch(ti->second.GetType()) + switch((*ti)->GetType()) { - case cmTarget::EXECUTABLE: - case cmTarget::STATIC_LIBRARY: - case cmTarget::SHARED_LIBRARY: - case cmTarget::MODULE_LIBRARY: - case cmTarget::OBJECT_LIBRARY: + case cmState::EXECUTABLE: + case cmState::STATIC_LIBRARY: + case cmState::SHARED_LIBRARY: + case cmState::MODULE_LIBRARY: + case cmState::OBJECT_LIBRARY: { - const char* prefix = (ti->second.GetType()==cmTarget::EXECUTABLE ? + const char* prefix = ((*ti)->GetType()==cmState::EXECUTABLE ? "[exe] " : "[lib] "); linkName2 += prefix; - linkName2 += ti->first; + linkName2 += (*ti)->GetName(); this->AppendLinkedResource(fout, linkName2, "virtual:/virtual", VirtualFolder); if (!this->GenerateLinkedResources) @@ -560,9 +564,9 @@ void cmExtraEclipseCDT4Generator::CreateLinksForTargets( } std::vector<cmSourceGroup> sourceGroups=makefile->GetSourceGroups(); // get the files from the source lists then add them to the groups - cmTarget* tgt = const_cast<cmTarget*>(&ti->second); + cmGeneratorTarget* gt = const_cast<cmGeneratorTarget*>(*ti); std::vector<cmSourceFile*> files; - tgt->GetSourceFiles(files, + gt->GetSourceFiles(files, makefile->GetSafeDefinition("CMAKE_BUILD_TYPE")); for(std::vector<cmSourceFile*>::const_iterator sfIt = files.begin(); sfIt != files.end(); @@ -634,7 +638,7 @@ void cmExtraEclipseCDT4Generator::CreateLinksToSubprojects( ++it) { std::string linkSourceDirectory = this->GetEclipsePath( - it->second[0]->GetMakefile()->GetCurrentSourceDirectory()); + it->second[0]->GetCurrentSourceDirectory()); // a linked resource must not point to a parent directory of .project or // .project itself if ((baseDir != linkSourceDirectory) && @@ -694,8 +698,8 @@ void cmExtraEclipseCDT4Generator::CreateCProjectFile() const { std::set<std::string> emmited; - const cmMakefile* mf - = this->GlobalGenerator->GetLocalGenerators()[0]->GetMakefile(); + cmLocalGenerator* lg = this->GlobalGenerator->GetLocalGenerators()[0]; + const cmMakefile* mf = lg->GetMakefile(); const std::string filename = this->HomeOutputDirectory + "/.cproject"; @@ -961,18 +965,13 @@ void cmExtraEclipseCDT4Generator::CreateCProjectFile() const it != this->GlobalGenerator->GetLocalGenerators().end(); ++it) { - cmGeneratorTargetsType targets = (*it)->GetMakefile() - ->GetGeneratorTargets(); - for (cmGeneratorTargetsType::iterator l = targets.begin(); + std::vector<cmGeneratorTarget*> targets = (*it)->GetGeneratorTargets(); + for (std::vector<cmGeneratorTarget*>::iterator l = targets.begin(); l != targets.end(); ++l) { - if (l->first->IsImported()) - { - continue; - } std::vector<std::string> includeDirs; std::string config = mf->GetSafeDefinition("CMAKE_BUILD_TYPE"); - (*it)->GetIncludeDirectories(includeDirs, l->second, "C", config); + (*it)->GetIncludeDirectories(includeDirs, *l, "C", config); this->AppendIncludeDirectories(fout, includeDirs, emmited); } } @@ -1031,52 +1030,54 @@ void cmExtraEclipseCDT4Generator::CreateCProjectFile() const it != this->GlobalGenerator->GetLocalGenerators().end(); ++it) { - const cmTargets& targets = (*it)->GetMakefile()->GetTargets(); - cmMakefile* makefile=(*it)->GetMakefile(); - std::string subdir = (*it)->Convert(makefile->GetCurrentBinaryDirectory(), + const std::vector<cmGeneratorTarget*> targets = + (*it)->GetGeneratorTargets(); + std::string subdir = (*it)->Convert((*it)->GetCurrentBinaryDirectory(), cmLocalGenerator::HOME_OUTPUT); if (subdir == ".") { subdir = ""; } - for(cmTargets::const_iterator ti=targets.begin(); ti!=targets.end(); ++ti) + for(std::vector<cmGeneratorTarget*>::const_iterator ti = + targets.begin(); ti!=targets.end(); ++ti) { - switch(ti->second.GetType()) + std::string targetName = (*ti)->GetName(); + switch((*ti)->GetType()) { - case cmTarget::GLOBAL_TARGET: + case cmState::GLOBAL_TARGET: { // Only add the global targets from CMAKE_BINARY_DIR, // not from the subdirs if (subdir.empty()) { - this->AppendTarget(fout, ti->first, make, makeArgs, subdir, ": "); + this->AppendTarget(fout, targetName, make, makeArgs, subdir, ": "); } } break; - case cmTarget::UTILITY: + case cmState::UTILITY: // Add all utility targets, except the Nightly/Continuous/ // Experimental-"sub"targets as e.g. NightlyStart - if (((ti->first.find("Nightly")==0) &&(ti->first!="Nightly")) - || ((ti->first.find("Continuous")==0)&&(ti->first!="Continuous")) - || ((ti->first.find("Experimental")==0) - && (ti->first!="Experimental"))) + if (((targetName.find("Nightly")==0) &&(targetName!="Nightly")) + || ((targetName.find("Continuous")==0)&&(targetName!="Continuous")) + || ((targetName.find("Experimental")==0) + && (targetName!="Experimental"))) { break; } - this->AppendTarget(fout, ti->first, make, makeArgs, subdir, ": "); + this->AppendTarget(fout, targetName, make, makeArgs, subdir, ": "); break; - case cmTarget::EXECUTABLE: - case cmTarget::STATIC_LIBRARY: - case cmTarget::SHARED_LIBRARY: - case cmTarget::MODULE_LIBRARY: - case cmTarget::OBJECT_LIBRARY: + case cmState::EXECUTABLE: + case cmState::STATIC_LIBRARY: + case cmState::SHARED_LIBRARY: + case cmState::MODULE_LIBRARY: + case cmState::OBJECT_LIBRARY: { - const char* prefix = (ti->second.GetType()==cmTarget::EXECUTABLE ? + const char* prefix = ((*ti)->GetType()==cmState::EXECUTABLE ? "[exe] " : "[lib] "); - this->AppendTarget(fout, ti->first, make, makeArgs, subdir, prefix); - std::string fastTarget = ti->first; + this->AppendTarget(fout, targetName, make, makeArgs, subdir, prefix); + std::string fastTarget = targetName; fastTarget += "/fast"; this->AppendTarget(fout, fastTarget, make, makeArgs, subdir, prefix); @@ -1085,20 +1086,21 @@ void cmExtraEclipseCDT4Generator::CreateCProjectFile() const { std::string virtDir = "[Targets]/"; virtDir += prefix; - virtDir += ti->first; + virtDir += targetName; std::string buildArgs = "-C \""; - buildArgs += makefile->GetHomeOutputDirectory(); + buildArgs += (*it)->GetBinaryDirectory(); buildArgs += "\" "; buildArgs += makeArgs; this->AppendTarget(fout, "Build", make, buildArgs, virtDir, "", - ti->first.c_str()); + targetName.c_str()); std::string cleanArgs = "-E chdir \""; - cleanArgs += makefile->GetCurrentBinaryDirectory(); + cleanArgs += (*it)->GetCurrentBinaryDirectory(); cleanArgs += "\" \""; cleanArgs += cmSystemTools::GetCMakeCommand(); cleanArgs += "\" -P \""; - cleanArgs += (*it)->GetTargetDirectory(ti->second); + cmGeneratorTarget* gt = *ti; + cleanArgs += (*it)->GetTargetDirectory(gt); cleanArgs += "/cmake_clean.cmake\""; this->AppendTarget(fout, "Clean", cmSystemTools::GetCMakeCommand(), cleanArgs, virtDir, "", ""); @@ -1149,8 +1151,8 @@ void cmExtraEclipseCDT4Generator::CreateCProjectFile() const fout << "</cconfiguration>\n" "</storageModule>\n" "<storageModule moduleId=\"cdtBuildSystem\" version=\"4.0.0\">\n" - "<project id=\"" << this->EscapeForXML(mf->GetProjectName()) - << ".null.1\" name=\"" << this->EscapeForXML(mf->GetProjectName()) + "<project id=\"" << this->EscapeForXML(lg->GetProjectName()) + << ".null.1\" name=\"" << this->EscapeForXML(lg->GetProjectName()) << "\"/>\n" "</storageModule>\n" "</cproject>\n" diff --git a/Source/cmExtraEclipseCDT4Generator.h b/Source/cmExtraEclipseCDT4Generator.h index ef99760..16675f2 100644 --- a/Source/cmExtraEclipseCDT4Generator.h +++ b/Source/cmExtraEclipseCDT4Generator.h @@ -100,7 +100,7 @@ private: std::set<std::string>& emittedDirs); static void AddEnvVar(cmGeneratedFileStream& fout, const char* envVar, - cmMakefile* mf); + cmLocalGenerator* lg); void CreateLinksToSubprojects(cmGeneratedFileStream& fout, const std::string& baseDir); diff --git a/Source/cmExtraKateGenerator.cxx b/Source/cmExtraKateGenerator.cxx index f83b5cf..ff5d3ab 100644 --- a/Source/cmExtraKateGenerator.cxx +++ b/Source/cmExtraKateGenerator.cxx @@ -17,7 +17,6 @@ #include "cmake.h" #include "cmSourceFile.h" #include "cmGeneratedFileStream.h" -#include "cmTarget.h" #include "cmSystemTools.h" #include <cmsys/SystemTools.hxx> @@ -46,21 +45,22 @@ cmExtraKateGenerator::cmExtraKateGenerator() void cmExtraKateGenerator::Generate() { - const cmMakefile* mf - = this->GlobalGenerator->GetLocalGenerators()[0]->GetMakefile(); - this->ProjectName = this->GenerateProjectName(mf->GetProjectName(), + cmLocalGenerator* lg = this->GlobalGenerator->GetLocalGenerators()[0]; + const cmMakefile* mf = lg->GetMakefile(); + this->ProjectName = this->GenerateProjectName(lg->GetProjectName(), mf->GetSafeDefinition("CMAKE_BUILD_TYPE"), - this->GetPathBasename(mf->GetHomeOutputDirectory())); + this->GetPathBasename(lg->GetBinaryDirectory())); this->UseNinja = (this->GlobalGenerator->GetName() == "Ninja"); - this->CreateKateProjectFile(mf); - this->CreateDummyKateProjectFile(mf); + this->CreateKateProjectFile(lg); + this->CreateDummyKateProjectFile(lg); } -void cmExtraKateGenerator::CreateKateProjectFile(const cmMakefile* mf) const +void cmExtraKateGenerator::CreateKateProjectFile( + const cmLocalGenerator* lg) const { - std::string filename = mf->GetHomeOutputDirectory(); + std::string filename = lg->GetBinaryDirectory(); filename += "/.kateproject"; cmGeneratedFileStream fout(filename.c_str()); if (!fout) @@ -68,31 +68,29 @@ void cmExtraKateGenerator::CreateKateProjectFile(const cmMakefile* mf) const return; } - std::string make = mf->GetRequiredDefinition("CMAKE_MAKE_PROGRAM"); - std::string args = mf->GetSafeDefinition("CMAKE_KATE_MAKE_ARGUMENTS"); - fout << "{\n" "\t\"name\": \"" << this->ProjectName << "\",\n" - "\t\"directory\": \"" << mf->GetHomeDirectory() << "\",\n" - "\t\"files\": [ { " << this->GenerateFilesString(mf) << "} ],\n"; - this->WriteTargets(mf, fout); + "\t\"directory\": \"" << lg->GetSourceDirectory() << "\",\n" + "\t\"files\": [ { " << this->GenerateFilesString(lg) << "} ],\n"; + this->WriteTargets(lg, fout); fout << "}\n"; } void -cmExtraKateGenerator::WriteTargets(const cmMakefile* mf, +cmExtraKateGenerator::WriteTargets(const cmLocalGenerator* lg, cmGeneratedFileStream& fout) const { + cmMakefile const* mf = lg->GetMakefile(); const std::string make = mf->GetRequiredDefinition("CMAKE_MAKE_PROGRAM"); const std::string makeArgs = mf->GetSafeDefinition( "CMAKE_KATE_MAKE_ARGUMENTS"); - const char* homeOutputDir = mf->GetHomeOutputDirectory(); + const char* homeOutputDir = lg->GetBinaryDirectory(); fout << "\t\"build\": {\n" - "\t\t\"directory\": \"" << mf->GetHomeOutputDirectory() << "\",\n" + "\t\t\"directory\": \"" << lg->GetBinaryDirectory() << "\",\n" "\t\t\"default_target\": \"all\",\n" "\t\t\"clean_target\": \"clean\",\n"; @@ -120,16 +118,18 @@ cmExtraKateGenerator::WriteTargets(const cmMakefile* mf, it != this->GlobalGenerator->GetLocalGenerators().end(); ++it) { - const cmTargets& targets = (*it)->GetMakefile()->GetTargets(); - cmMakefile* makefile=(*it)->GetMakefile(); - std::string currentDir = makefile->GetCurrentBinaryDirectory(); - bool topLevel = (currentDir == makefile->GetHomeOutputDirectory()); + const std::vector<cmGeneratorTarget*> targets = + (*it)->GetGeneratorTargets(); + std::string currentDir = (*it)->GetCurrentBinaryDirectory(); + bool topLevel = (currentDir == (*it)->GetBinaryDirectory()); - for(cmTargets::const_iterator ti=targets.begin(); ti!=targets.end(); ++ti) + for(std::vector<cmGeneratorTarget*>::const_iterator ti = + targets.begin(); ti!=targets.end(); ++ti) { - switch(ti->second.GetType()) + std::string targetName = (*ti)->GetName(); + switch((*ti)->GetType()) { - case cmTarget::GLOBAL_TARGET: + case cmState::GLOBAL_TARGET: { bool insertTarget = false; // Only add the global targets from CMAKE_BINARY_DIR, @@ -139,9 +139,9 @@ cmExtraKateGenerator::WriteTargets(const cmMakefile* mf, insertTarget = true; // only add the "edit_cache" target if it's not ccmake, because // this will not work within the IDE - if (ti->first == "edit_cache") + if (targetName == "edit_cache") { - const char* editCommand = makefile->GetDefinition + const char* editCommand = (*it)->GetMakefile()->GetDefinition ("CMAKE_EDIT_COMMAND"); if (editCommand == 0) { @@ -155,34 +155,35 @@ cmExtraKateGenerator::WriteTargets(const cmMakefile* mf, } if (insertTarget) { - this->AppendTarget(fout, ti->first, make, makeArgs, + this->AppendTarget(fout, targetName, make, makeArgs, currentDir, homeOutputDir); } } break; - case cmTarget::UTILITY: + case cmState::UTILITY: // Add all utility targets, except the Nightly/Continuous/ // Experimental-"sub"targets as e.g. NightlyStart - if (((ti->first.find("Nightly")==0) &&(ti->first!="Nightly")) - || ((ti->first.find("Continuous")==0)&&(ti->first!="Continuous")) - || ((ti->first.find("Experimental")==0) - && (ti->first!="Experimental"))) + if (((targetName.find("Nightly")==0) &&(targetName!="Nightly")) + || ((targetName.find("Continuous")==0) + &&(targetName!="Continuous")) + || ((targetName.find("Experimental")==0) + && (targetName!="Experimental"))) { break; } - this->AppendTarget(fout, ti->first, make, makeArgs, + this->AppendTarget(fout, targetName, make, makeArgs, currentDir, homeOutputDir); break; - case cmTarget::EXECUTABLE: - case cmTarget::STATIC_LIBRARY: - case cmTarget::SHARED_LIBRARY: - case cmTarget::MODULE_LIBRARY: - case cmTarget::OBJECT_LIBRARY: + case cmState::EXECUTABLE: + case cmState::STATIC_LIBRARY: + case cmState::SHARED_LIBRARY: + case cmState::MODULE_LIBRARY: + case cmState::OBJECT_LIBRARY: { - this->AppendTarget(fout, ti->first, make, makeArgs, + this->AppendTarget(fout, targetName, make, makeArgs, currentDir, homeOutputDir); - std::string fastTarget = ti->first; + std::string fastTarget = targetName; fastTarget += "/fast"; this->AppendTarget(fout, fastTarget, make, makeArgs, currentDir, homeOutputDir); @@ -234,9 +235,10 @@ cmExtraKateGenerator::AppendTarget(cmGeneratedFileStream& fout, void -cmExtraKateGenerator::CreateDummyKateProjectFile(const cmMakefile* mf) const +cmExtraKateGenerator::CreateDummyKateProjectFile( + const cmLocalGenerator* lg) const { - std::string filename = mf->GetHomeOutputDirectory(); + std::string filename = lg->GetBinaryDirectory(); filename += "/"; filename += this->ProjectName; filename += ".kateproject"; @@ -252,23 +254,23 @@ cmExtraKateGenerator::CreateDummyKateProjectFile(const cmMakefile* mf) const std::string -cmExtraKateGenerator::GenerateFilesString(const cmMakefile* mf) const +cmExtraKateGenerator::GenerateFilesString(const cmLocalGenerator* lg) const { - std::string s = mf->GetHomeDirectory(); + std::string s = lg->GetSourceDirectory(); s += "/.git"; if(cmSystemTools::FileExists(s.c_str())) { return std::string("\"git\": 1 "); } - s = mf->GetHomeDirectory(); + s = lg->GetSourceDirectory(); s += "/.svn"; if(cmSystemTools::FileExists(s.c_str())) { return std::string("\"svn\": 1 "); } - s = mf->GetHomeDirectory(); + s = lg->GetSourceDirectory(); s += "/"; std::set<std::string> files; diff --git a/Source/cmExtraKateGenerator.h b/Source/cmExtraKateGenerator.h index f800feb..281c1ef 100644 --- a/Source/cmExtraKateGenerator.h +++ b/Source/cmExtraKateGenerator.h @@ -16,8 +16,6 @@ #include "cmExternalMakefileProjectGenerator.h" class cmLocalGenerator; -class cmMakefile; -class cmTarget; class cmGeneratedFileStream; /** \class cmExtraKateGenerator @@ -39,9 +37,10 @@ public: virtual void Generate(); private: - void CreateKateProjectFile(const cmMakefile* mf) const; - void CreateDummyKateProjectFile(const cmMakefile* mf) const; - void WriteTargets(const cmMakefile* mf, cmGeneratedFileStream& fout) const; + void CreateKateProjectFile(const cmLocalGenerator* lg) const; + void CreateDummyKateProjectFile(const cmLocalGenerator* lg) const; + void WriteTargets(const cmLocalGenerator* lg, + cmGeneratedFileStream& fout) const; void AppendTarget(cmGeneratedFileStream& fout, const std::string& target, const std::string& make, @@ -49,7 +48,7 @@ private: const std::string& path, const char* homeOutputDir) const; - std::string GenerateFilesString(const cmMakefile* mf) const; + std::string GenerateFilesString(const cmLocalGenerator* lg) const; std::string GetPathBasename(const std::string& path) const; std::string GenerateProjectName(const std::string& name, const std::string& type, diff --git a/Source/cmExtraSublimeTextGenerator.cxx b/Source/cmExtraSublimeTextGenerator.cxx index 163a75b..92d38b9 100644 --- a/Source/cmExtraSublimeTextGenerator.cxx +++ b/Source/cmExtraSublimeTextGenerator.cxx @@ -20,7 +20,6 @@ #include "cmMakefile.h" #include "cmSourceFile.h" #include "cmSystemTools.h" -#include "cmTarget.h" #include <cmsys/SystemTools.hxx> @@ -77,9 +76,8 @@ void cmExtraSublimeTextGenerator::Generate() void cmExtraSublimeTextGenerator::CreateProjectFile( const std::vector<cmLocalGenerator*>& lgs) { - const cmMakefile* mf=lgs[0]->GetMakefile(); - std::string outputDir=mf->GetCurrentBinaryDirectory(); - std::string projectName=mf->GetProjectName(); + std::string outputDir=lgs[0]->GetCurrentBinaryDirectory(); + std::string projectName=lgs[0]->GetProjectName(); const std::string filename = outputDir + "/" + projectName + ".sublime-project"; @@ -99,8 +97,8 @@ void cmExtraSublimeTextGenerator } const std::string &sourceRootRelativeToOutput = cmSystemTools::RelativePath( - mf->GetHomeOutputDirectory(), - mf->GetHomeDirectory()); + lgs[0]->GetBinaryDirectory(), + lgs[0]->GetSourceDirectory()); // Write the folder entries to the project file fout << "{\n"; fout << "\t\"folders\":\n\t[\n\t"; @@ -108,8 +106,8 @@ void cmExtraSublimeTextGenerator { fout << "\t{\n\t\t\t\"path\": \"" << sourceRootRelativeToOutput << "\""; const std::string &outputRelativeToSourceRoot = - cmSystemTools::RelativePath(mf->GetHomeDirectory(), - mf->GetHomeOutputDirectory()); + cmSystemTools::RelativePath(lgs[0]->GetSourceDirectory(), + lgs[0]->GetBinaryDirectory()); if ((!outputRelativeToSourceRoot.empty()) && ((outputRelativeToSourceRoot.length() < 3) || (outputRelativeToSourceRoot.substr(0, 3) != "../"))) @@ -163,52 +161,54 @@ void cmExtraSublimeTextGenerator:: lg!=lgs.end(); lg++) { cmMakefile* makefile=(*lg)->GetMakefile(); - cmTargets& targets=makefile->GetTargets(); - for (cmTargets::iterator ti = targets.begin(); + std::vector<cmGeneratorTarget*> targets=(*lg)->GetGeneratorTargets(); + for (std::vector<cmGeneratorTarget*>::iterator ti = targets.begin(); ti != targets.end(); ti++) { - switch(ti->second.GetType()) + std::string targetName = (*ti)->GetName(); + switch((*ti)->GetType()) { - case cmTarget::GLOBAL_TARGET: + case cmState::GLOBAL_TARGET: { // Only add the global targets from CMAKE_BINARY_DIR, // not from the subdirs - if (strcmp(makefile->GetCurrentBinaryDirectory(), - makefile->GetHomeOutputDirectory())==0) + if (strcmp((*lg)->GetCurrentBinaryDirectory(), + (*lg)->GetBinaryDirectory())==0) { - this->AppendTarget(fout, ti->first, *lg, 0, + this->AppendTarget(fout, targetName, *lg, 0, make.c_str(), makefile, compiler.c_str(), sourceFileFlags, false); } } break; - case cmTarget::UTILITY: + case cmState::UTILITY: // Add all utility targets, except the Nightly/Continuous/ // Experimental-"sub"targets as e.g. NightlyStart - if (((ti->first.find("Nightly")==0) &&(ti->first!="Nightly")) - || ((ti->first.find("Continuous")==0)&&(ti->first!="Continuous")) - || ((ti->first.find("Experimental")==0) - && (ti->first!="Experimental"))) + if (((targetName.find("Nightly")==0) &&(targetName!="Nightly")) + || ((targetName.find("Continuous")==0) + &&(targetName!="Continuous")) + || ((targetName.find("Experimental")==0) + && (targetName!="Experimental"))) { break; } - this->AppendTarget(fout, ti->first, *lg, 0, + this->AppendTarget(fout, targetName, *lg, 0, make.c_str(), makefile, compiler.c_str(), sourceFileFlags, false); break; - case cmTarget::EXECUTABLE: - case cmTarget::STATIC_LIBRARY: - case cmTarget::SHARED_LIBRARY: - case cmTarget::MODULE_LIBRARY: - case cmTarget::OBJECT_LIBRARY: + case cmState::EXECUTABLE: + case cmState::STATIC_LIBRARY: + case cmState::SHARED_LIBRARY: + case cmState::MODULE_LIBRARY: + case cmState::OBJECT_LIBRARY: { - this->AppendTarget(fout, ti->first, *lg, &ti->second, + this->AppendTarget(fout, targetName, *lg, *ti, make.c_str(), makefile, compiler.c_str(), sourceFileFlags, false); - std::string fastTarget = ti->first; + std::string fastTarget = targetName; fastTarget += "/fast"; - this->AppendTarget(fout, fastTarget, *lg, &ti->second, + this->AppendTarget(fout, fastTarget, *lg, *ti, make.c_str(), makefile, compiler.c_str(), sourceFileFlags, false); } @@ -224,7 +224,7 @@ void cmExtraSublimeTextGenerator:: AppendTarget(cmGeneratedFileStream& fout, const std::string& targetName, cmLocalGenerator* lg, - cmTarget* target, + cmGeneratorTarget* target, const char* make, const cmMakefile* makefile, const char*, //compiler @@ -234,8 +234,6 @@ void cmExtraSublimeTextGenerator:: if (target != 0) { - cmGeneratorTarget *gtgt = this->GlobalGenerator - ->GetGeneratorTarget(target); std::vector<cmSourceFile*> sourceFiles; target->GetSourceFiles(sourceFiles, makefile->GetSafeDefinition("CMAKE_BUILD_TYPE")); @@ -255,9 +253,9 @@ void cmExtraSublimeTextGenerator:: } std::vector<std::string>& flags = sourceFileFlagsIter->second; std::string flagsString = - this->ComputeFlagsForObject(*iter, lg, target, gtgt); + this->ComputeFlagsForObject(*iter, lg, target); std::string definesString = - this->ComputeDefines(*iter, lg, target, gtgt); + this->ComputeDefines(*iter, lg, target); flags.clear(); cmsys::RegularExpression flagRegex; // Regular expression to extract compiler flags from a string @@ -302,7 +300,7 @@ void cmExtraSublimeTextGenerator:: { fout << ",\n\t"; } - fout << "\t{\n\t\t\t\"name\": \"" << makefile->GetProjectName() << " - " << + fout << "\t{\n\t\t\t\"name\": \"" << lg->GetProjectName() << " - " << targetName << "\",\n"; fout << "\t\t\t\"cmd\": [" << this->BuildMakeCommand(make, makefileName.c_str(), targetName) << @@ -365,7 +363,6 @@ std::string cmExtraSublimeTextGenerator::BuildMakeCommand( std::string cmExtraSublimeTextGenerator::ComputeFlagsForObject(cmSourceFile* source, cmLocalGenerator* lg, - cmTarget *target, cmGeneratorTarget* gtgt) { std::string flags; @@ -390,7 +387,7 @@ cmExtraSublimeTextGenerator::ComputeFlagsForObject(cmSourceFile* source, // } // Add shared-library flags if needed. - lg->AddCMP0018Flags(flags, target, language, config); + lg->AddCMP0018Flags(flags, gtgt, language, config); // Add include directory flags. { @@ -405,7 +402,7 @@ cmExtraSublimeTextGenerator::ComputeFlagsForObject(cmSourceFile* source, lg->AppendFlags(flags, makefile->GetDefineFlags()); // Add target-specific flags. - lg->AddCompileOptions(flags, target, language, config); + lg->AddCompileOptions(flags, gtgt, language, config); // Add source file specific flags. lg->AppendFlags(flags, source->GetProperty("COMPILE_FLAGS")); @@ -419,8 +416,8 @@ cmExtraSublimeTextGenerator::ComputeFlagsForObject(cmSourceFile* source, // void cmMakefileTargetGenerator::WriteTargetLanguageFlags(). std::string cmExtraSublimeTextGenerator:: -ComputeDefines(cmSourceFile *source, cmLocalGenerator* lg, cmTarget *target, - cmGeneratorTarget*) +ComputeDefines(cmSourceFile *source, cmLocalGenerator* lg, + cmGeneratorTarget* target) { std::set<std::string> defines; diff --git a/Source/cmExtraSublimeTextGenerator.h b/Source/cmExtraSublimeTextGenerator.h index 4173b7d..cf31ee0 100644 --- a/Source/cmExtraSublimeTextGenerator.h +++ b/Source/cmExtraSublimeTextGenerator.h @@ -18,7 +18,6 @@ class cmLocalGenerator; class cmMakefile; -class cmTarget; class cmGeneratedFileStream; class cmGeneratorTarget; @@ -67,7 +66,7 @@ private: void AppendTarget(cmGeneratedFileStream& fout, const std::string& targetName, cmLocalGenerator* lg, - cmTarget* target, + cmGeneratorTarget* target, const char* make, const cmMakefile* makefile, const char* compiler, @@ -79,11 +78,10 @@ private: */ std::string ComputeFlagsForObject(cmSourceFile *source, cmLocalGenerator* lg, - cmTarget *target, cmGeneratorTarget* gtgt); std::string ComputeDefines(cmSourceFile *source, cmLocalGenerator* lg, - cmTarget *target, cmGeneratorTarget* gtgt); + cmGeneratorTarget* gtgt); }; #endif diff --git a/Source/cmFLTKWrapUICommand.cxx b/Source/cmFLTKWrapUICommand.cxx index 12adfd9..d17d664 100644 --- a/Source/cmFLTKWrapUICommand.cxx +++ b/Source/cmFLTKWrapUICommand.cxx @@ -129,45 +129,6 @@ void cmFLTKWrapUICommand::FinalPass() cmSystemTools::Message(msg.c_str(),"Warning"); return; } - std::vector<cmSourceFile*> srcs; - target->GetSourceFiles(srcs, ""); - bool found = false; - for (unsigned int i = 0; i < srcs.size(); ++i) - { - if (srcs[i]->GetFullPath() == - this->GeneratedSourcesClasses[0]->GetFullPath()) - { - found = true; - break; - } - } - if (!found) - { - std::string msg = - "In CMake 2.2 the FLTK_WRAP_UI command sets a variable to the list of " - "source files that should be added to your executable or library. It " - "appears that you have not added these source files to your target. " - "You should change your CMakeLists.txt file to " - "directly add the generated files to the target. " - "For example FTLK_WRAP_UI(foo src1 src2 src3) " - "will create a variable named foo_FLTK_UI_SRCS that contains the list " - "of sources to add to your target when you call ADD_LIBRARY or " - "ADD_EXECUTABLE. For now CMake will add the sources to your target " - "for you as was done in CMake 2.0 and earlier. In the future this may " - "become an error."; - msg +="The problem was found while processing the source directory: "; - msg += this->Makefile->GetCurrentSourceDirectory(); - cmSystemTools::Message(msg.c_str(),"Warning"); - // first we add the rules for all the .fl to .h and .cxx files - size_t lastHeadersClass = this->GeneratedSourcesClasses.size(); - - // Generate code for all the .fl files - for(size_t classNum = 0; classNum < lastHeadersClass; classNum++) - { - this->Makefile->GetTargets()[this->Target] - .AddSource(this->GeneratedSourcesClasses[classNum]->GetFullPath()); - } - } } diff --git a/Source/cmFileCommand.cxx b/Source/cmFileCommand.cxx index 87faf84..df95d9d 100644 --- a/Source/cmFileCommand.cxx +++ b/Source/cmFileCommand.cxx @@ -15,7 +15,6 @@ #include "cmHexFileConverter.h" #include "cmInstallType.h" #include "cmFileTimeComparison.h" -#include "cmLocalGenerator.h" #include "cmGlobalGenerator.h" #include "cmCryptoHash.h" #include "cmAlgorithms.h" diff --git a/Source/cmFileTimeComparison.cxx b/Source/cmFileTimeComparison.cxx index 13e2a66..279b61d 100644 --- a/Source/cmFileTimeComparison.cxx +++ b/Source/cmFileTimeComparison.cxx @@ -148,7 +148,7 @@ int cmFileTimeComparisonInternal::Compare(cmFileTimeComparison_Type* s1, cmFileTimeComparison_Type* s2) { #if !defined(_WIN32) || defined(__CYGWIN__) -# if cmsys_STAT_HAS_ST_MTIM +# if CMake_STAT_HAS_ST_MTIM // Compare using nanosecond resolution. if(s1->st_mtim.tv_sec < s2->st_mtim.tv_sec) { @@ -166,6 +166,24 @@ int cmFileTimeComparisonInternal::Compare(cmFileTimeComparison_Type* s1, { return 1; } +# elif CMake_STAT_HAS_ST_MTIMESPEC + // Compare using nanosecond resolution. + if(s1->st_mtimespec.tv_sec < s2->st_mtimespec.tv_sec) + { + return -1; + } + else if(s1->st_mtimespec.tv_sec > s2->st_mtimespec.tv_sec) + { + return 1; + } + else if(s1->st_mtimespec.tv_nsec < s2->st_mtimespec.tv_nsec) + { + return -1; + } + else if(s1->st_mtimespec.tv_nsec > s2->st_mtimespec.tv_nsec) + { + return 1; + } # else // Compare using 1 second resolution. if(s1->st_mtime < s2->st_mtime) @@ -190,7 +208,7 @@ bool cmFileTimeComparisonInternal::TimesDiffer(cmFileTimeComparison_Type* s1, cmFileTimeComparison_Type* s2) { #if !defined(_WIN32) || defined(__CYGWIN__) -# if cmsys_STAT_HAS_ST_MTIM +# if CMake_STAT_HAS_ST_MTIM // Times are integers in units of 1ns. long long bil = 1000000000; long long t1 = s1->st_mtim.tv_sec * bil + s1->st_mtim.tv_nsec; @@ -207,6 +225,23 @@ bool cmFileTimeComparisonInternal::TimesDiffer(cmFileTimeComparison_Type* s1, { return false; } +# elif CMake_STAT_HAS_ST_MTIMESPEC + // Times are integers in units of 1ns. + long long bil = 1000000000; + long long t1 = s1->st_mtimespec.tv_sec * bil + s1->st_mtimespec.tv_nsec; + long long t2 = s2->st_mtimespec.tv_sec * bil + s2->st_mtimespec.tv_nsec; + if(t1 < t2) + { + return (t2 - t1) >= bil; + } + else if(t2 < t1) + { + return (t1 - t2) >= bil; + } + else + { + return false; + } # else // Times are integers in units of 1s. if(s1->st_mtime < s2->st_mtime) diff --git a/Source/cmFortranLexer.cxx b/Source/cmFortranLexer.cxx index b727f0e..6779c1a 100644 --- a/Source/cmFortranLexer.cxx +++ b/Source/cmFortranLexer.cxx @@ -1,6 +1,6 @@ /*============================================================================ CMake - Cross Platform Makefile Generator - Copyright 2000-2009 Kitware, Inc., Insight Software Consortium + Copyright 2000-2015 Kitware, Inc., Insight Software Consortium Distributed under the OSI-approved BSD License (the "License"); see accompanying file Copyright.txt for details. @@ -20,7 +20,7 @@ #define FLEX_SCANNER #define YY_FLEX_MAJOR_VERSION 2 #define YY_FLEX_MINOR_VERSION 5 -#define YY_FLEX_SUBMINOR_VERSION 35 +#define YY_FLEX_SUBMINOR_VERSION 39 #if YY_FLEX_SUBMINOR_VERSION > 0 #define FLEX_BETA #endif @@ -190,11 +190,17 @@ typedef void* yyscan_t; typedef struct yy_buffer_state *YY_BUFFER_STATE; #endif +#ifndef YY_TYPEDEF_YY_SIZE_T +#define YY_TYPEDEF_YY_SIZE_T +typedef size_t yy_size_t; +#endif + #define EOB_ACT_CONTINUE_SCAN 0 #define EOB_ACT_END_OF_FILE 1 #define EOB_ACT_LAST_MATCH 2 #define YY_LESS_LINENO(n) + #define YY_LINENO_REWIND_TO(ptr) /* Return all but the first "n" matched characters back to the input stream. */ #define yyless(n) \ @@ -212,11 +218,6 @@ typedef struct yy_buffer_state *YY_BUFFER_STATE; #define unput(c) yyunput( c, yyg->yytext_ptr , yyscanner ) -#ifndef YY_TYPEDEF_YY_SIZE_T -#define YY_TYPEDEF_YY_SIZE_T -typedef size_t yy_size_t; -#endif - #ifndef YY_STRUCT_YY_BUFFER_STATE #define YY_STRUCT_YY_BUFFER_STATE struct yy_buffer_state @@ -234,7 +235,7 @@ struct yy_buffer_state /* Number of characters read into yy_ch_buf, not including EOB * characters. */ - int yy_n_chars; + yy_size_t yy_n_chars; /* Whether we "own" the buffer - i.e., we know we created it, * and can realloc() it to grow it, and should free() it to @@ -313,7 +314,7 @@ static void cmFortran_yy_init_buffer (YY_BUFFER_STATE b,FILE *file ,yyscan_t yys YY_BUFFER_STATE cmFortran_yy_scan_buffer (char *base,yy_size_t size ,yyscan_t yyscanner ); YY_BUFFER_STATE cmFortran_yy_scan_string (yyconst char *yy_str ,yyscan_t yyscanner ); -YY_BUFFER_STATE cmFortran_yy_scan_bytes (yyconst char *bytes,int len ,yyscan_t yyscanner ); +YY_BUFFER_STATE cmFortran_yy_scan_bytes (yyconst char *bytes,yy_size_t len ,yyscan_t yyscanner ); void *cmFortran_yyalloc (yy_size_t ,yyscan_t yyscanner ); void *cmFortran_yyrealloc (void *,yy_size_t ,yyscan_t yyscanner ); @@ -345,7 +346,7 @@ void cmFortran_yyfree (void * ,yyscan_t yyscanner ); /* Begin user sect3 */ -#define cmFortran_yywrap(n) 1 +#define cmFortran_yywrap(yyscanner) 1 #define YY_SKIP_YYWRAP typedef unsigned char YY_CHAR; @@ -369,8 +370,8 @@ static void yy_fatal_error (yyconst char msg[] ,yyscan_t yyscanner ); *yy_cp = '\0'; \ yyg->yy_c_buf_p = yy_cp; -#define YY_NUM_RULES 44 -#define YY_END_OF_BUFFER 45 +#define YY_NUM_RULES 45 +#define YY_END_OF_BUFFER 46 /* This struct is not used in this scanner, but its presence is necessary. */ struct yy_trans_info @@ -378,26 +379,27 @@ struct yy_trans_info flex_int32_t yy_verify; flex_int32_t yy_nxt; }; -static yyconst flex_int16_t yy_accept[165] = +static yyconst flex_int16_t yy_accept[173] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 45, 39, 41, 40, 43, 1, 39, 32, 2, 34, - 39, 40, 37, 39, 38, 39, 38, 41, 39, 40, - 39, 38, 9, 8, 9, 4, 3, 39, 0, 10, - 0, 0, 0, 0, 0, 32, 32, 33, 35, 37, - 39, 38, 0, 42, 38, 0, 0, 0, 0, 0, - 0, 0, 0, 39, 0, 11, 38, 0, 0, 5, - 0, 0, 0, 28, 0, 0, 32, 32, 32, 32, - 0, 0, 0, 0, 0, 22, 0, 0, 0, 0, - 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, + 46, 40, 42, 41, 44, 1, 40, 33, 2, 35, + 40, 41, 38, 40, 39, 40, 39, 42, 40, 41, + 40, 39, 9, 8, 9, 4, 3, 40, 0, 10, + 0, 0, 0, 0, 0, 33, 33, 34, 36, 38, + 40, 39, 0, 43, 39, 0, 0, 0, 12, 0, + 0, 0, 0, 0, 0, 40, 0, 11, 39, 0, + 0, 5, 0, 0, 0, 29, 0, 0, 33, 33, + 33, 33, 0, 0, 12, 12, 0, 0, 0, 23, + 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 29, 30, 0, 0, 0, 0, 0, 0, - 0, 23, 24, 0, 0, 0, 0, 0, 0, 0, - 0, 31, 26, 0, 0, 19, 0, 0, 25, 20, - 0, 0, 18, 0, 0, 17, 27, 0, 0, 16, - 21, 0, 7, 36, 7, 14, 0, 13, 15, 0, - 0, 0, 12, 0 + 0, 0, 0, 0, 0, 0, 0, 0, 30, 31, + 0, 0, 0, 0, 0, 0, 0, 24, 25, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 32, 27, + 0, 0, 20, 0, 0, 26, 21, 0, 0, 0, + 19, 0, 0, 18, 28, 0, 0, 17, 22, 0, + 7, 37, 7, 15, 0, 14, 16, 0, 0, 0, + 13, 0 } ; static yyconst flex_int32_t yy_ec[256] = @@ -441,178 +443,186 @@ static yyconst flex_int32_t yy_meta[42] = 7 } ; -static yyconst flex_int16_t yy_base[174] = +static yyconst flex_int16_t yy_base[182] = { 0, - 0, 40, 0, 41, 188, 48, 44, 54, 56, 65, - 186, 0, 505, 505, 171, 505, 81, 74, 505, 505, - 158, 505, 151, 137, 0, 85, 122, 87, 153, 145, - 194, 226, 505, 143, 91, 505, 505, 0, 142, 505, - 266, 34, 70, 74, 34, 122, 141, 505, 0, 505, - 112, 0, 98, 505, 0, 154, 306, 0, 43, 133, - 139, 46, 130, 347, 130, 505, 0, 121, 163, 179, - 104, 156, 129, 176, 147, 178, 214, 267, 273, 292, - 279, 179, 249, 280, 257, 265, 288, 289, 116, 107, - 317, 505, 287, 289, 291, 302, 307, 310, 307, 311, - - 316, 326, 329, 333, 332, 336, 347, 345, 349, 101, - 86, 346, 505, 505, 350, 351, 353, 350, 357, 362, - 362, 505, 505, 367, 369, 371, 366, 372, 56, 47, - 374, 505, 505, 374, 379, 505, 374, 387, 505, 505, - 387, 391, 505, 117, 0, 505, 505, 392, 394, 505, - 505, 394, 505, 505, 505, 505, 395, 419, 505, 429, - 0, 25, 505, 505, 446, 453, 459, 462, 469, 476, - 483, 490, 497 + 0, 40, 0, 41, 220, 48, 44, 54, 56, 65, + 220, 0, 535, 535, 216, 535, 81, 74, 535, 535, + 186, 535, 153, 145, 0, 85, 122, 87, 154, 155, + 195, 227, 535, 147, 91, 535, 535, 0, 147, 535, + 267, 34, 70, 74, 34, 122, 141, 535, 0, 535, + 112, 0, 98, 535, 0, 156, 307, 0, 143, 43, + 155, 151, 48, 101, 130, 348, 130, 535, 0, 121, + 197, 165, 172, 244, 182, 183, 191, 248, 273, 293, + 308, 314, 321, 246, 275, 216, 269, 299, 304, 327, + 307, 304, 312, 116, 107, 367, 535, 327, 334, 347, + + 347, 350, 352, 349, 354, 359, 357, 363, 366, 365, + 369, 372, 369, 373, 374, 101, 86, 372, 535, 535, + 378, 380, 386, 382, 388, 388, 389, 535, 535, 393, + 394, 396, 392, 430, 400, 56, 47, 403, 535, 535, + 409, 414, 535, 409, 416, 535, 535, 416, 419, 441, + 535, 117, 0, 535, 535, 423, 426, 535, 535, 430, + 535, 535, 535, 535, 432, 457, 535, 459, 0, 25, + 535, 535, 476, 483, 489, 492, 499, 506, 513, 520, + 527 } ; -static yyconst flex_int16_t yy_def[174] = +static yyconst flex_int16_t yy_def[182] = { 0, - 164, 1, 1, 1, 1, 1, 165, 165, 165, 165, - 164, 166, 164, 164, 167, 164, 166, 164, 164, 164, - 166, 164, 164, 166, 168, 166, 168, 164, 166, 164, - 169, 164, 164, 164, 164, 164, 164, 166, 167, 164, - 164, 164, 164, 164, 164, 164, 170, 164, 166, 164, - 166, 168, 164, 164, 27, 164, 164, 57, 164, 164, - 164, 164, 164, 169, 169, 164, 32, 164, 164, 164, - 164, 164, 164, 164, 164, 164, 170, 170, 170, 170, - 164, 164, 164, 164, 164, 164, 164, 164, 164, 164, - 164, 164, 164, 164, 164, 164, 164, 164, 164, 164, - - 164, 164, 164, 164, 164, 164, 164, 164, 164, 164, - 164, 164, 164, 164, 164, 164, 164, 164, 164, 164, - 164, 164, 164, 164, 164, 164, 164, 164, 164, 164, - 164, 164, 164, 164, 164, 164, 164, 164, 164, 164, - 164, 164, 164, 171, 172, 164, 164, 164, 164, 164, - 164, 164, 164, 164, 164, 164, 164, 164, 164, 164, - 173, 173, 164, 0, 164, 164, 164, 164, 164, 164, - 164, 164, 164 + 172, 1, 1, 1, 1, 1, 173, 173, 173, 173, + 172, 174, 172, 172, 175, 172, 174, 172, 172, 172, + 174, 172, 172, 174, 176, 174, 176, 172, 172, 172, + 177, 172, 172, 172, 172, 172, 172, 174, 175, 172, + 172, 172, 172, 172, 172, 172, 178, 172, 174, 172, + 174, 176, 172, 172, 27, 172, 172, 57, 174, 172, + 172, 172, 172, 172, 172, 177, 177, 172, 32, 172, + 172, 172, 172, 172, 172, 172, 172, 172, 178, 178, + 178, 178, 172, 172, 172, 172, 172, 172, 172, 172, + 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, + + 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, + 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, + 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, + 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, + 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, + 172, 179, 180, 172, 172, 172, 172, 172, 172, 172, + 172, 172, 172, 172, 172, 172, 172, 172, 181, 181, + 172, 0, 172, 172, 172, 172, 172, 172, 172, 172, + 172 } ; -static yyconst flex_int16_t yy_nxt[547] = +static yyconst flex_int16_t yy_nxt[577] = { 0, 12, 13, 14, 13, 13, 15, 16, 12, 17, 18, 19, 12, 20, 12, 21, 22, 12, 23, 12, 24, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 26, 27, 25, 25, 25, 25, 25, 25, 25, 25, - 25, 28, 28, 163, 28, 28, 34, 29, 29, 28, - 30, 145, 28, 35, 36, 29, 34, 71, 34, 31, - 144, 76, 37, 35, 36, 35, 83, 34, 71, 32, - 32, 37, 76, 88, 35, 46, 46, 83, 46, 47, - 32, 32, 41, 48, 88, 41, 53, 54, 56, 53, - 130, 56, 69, 70, 57, 69, 72, 73, 74, 53, - - 54, 75, 53, 42, 43, 129, 44, 72, 73, 74, - 45, 111, 75, 81, 42, 43, 81, 44, 154, 154, - 110, 45, 38, 46, 46, 90, 46, 47, 93, 38, - 38, 48, 66, 38, 89, 55, 38, 82, 38, 93, - 38, 38, 78, 46, 40, 78, 79, 68, 82, 63, - 80, 96, 38, 55, 58, 56, 51, 58, 56, 84, - 85, 57, 96, 86, 69, 70, 87, 69, 99, 50, - 84, 85, 49, 40, 86, 59, 60, 87, 61, 99, - 91, 94, 62, 91, 95, 164, 59, 60, 92, 61, - 30, 164, 94, 62, 64, 95, 66, 164, 97, 164, - - 100, 64, 64, 98, 164, 64, 101, 64, 64, 97, - 64, 100, 64, 64, 98, 78, 46, 101, 78, 79, - 164, 164, 164, 80, 64, 64, 65, 65, 66, 65, - 65, 65, 65, 65, 65, 65, 65, 65, 65, 67, - 65, 65, 65, 65, 65, 65, 67, 67, 67, 67, - 67, 67, 67, 67, 67, 67, 65, 67, 67, 67, - 67, 67, 67, 67, 67, 67, 67, 41, 78, 46, - 41, 78, 79, 102, 78, 46, 80, 78, 79, 105, - 81, 164, 80, 81, 102, 164, 164, 106, 42, 43, - 105, 44, 107, 78, 46, 45, 78, 79, 106, 42, - - 43, 80, 44, 107, 82, 103, 45, 58, 104, 108, - 58, 109, 112, 113, 114, 82, 103, 164, 91, 104, - 108, 91, 109, 112, 113, 114, 92, 115, 59, 60, - 116, 61, 117, 118, 119, 62, 164, 120, 115, 59, - 60, 116, 61, 117, 118, 119, 62, 64, 120, 66, - 164, 121, 164, 122, 64, 64, 123, 124, 64, 125, - 64, 64, 121, 64, 122, 64, 64, 123, 124, 126, - 125, 127, 128, 131, 132, 133, 134, 64, 64, 135, - 126, 136, 127, 128, 131, 132, 133, 134, 137, 138, - 135, 139, 136, 140, 141, 142, 143, 146, 147, 137, - - 138, 148, 139, 149, 140, 141, 142, 143, 146, 147, - 150, 151, 148, 152, 149, 156, 157, 158, 159, 164, - 160, 150, 151, 160, 152, 164, 156, 157, 158, 159, - 160, 164, 164, 160, 164, 161, 164, 164, 164, 164, - 164, 164, 164, 164, 164, 161, 33, 33, 33, 33, - 33, 33, 33, 38, 164, 164, 164, 38, 38, 39, - 39, 39, 39, 39, 39, 39, 52, 164, 52, 65, - 65, 65, 65, 65, 65, 65, 77, 77, 77, 77, - 77, 77, 77, 153, 153, 153, 164, 153, 153, 153, - 155, 164, 155, 164, 155, 155, 155, 162, 162, 162, - - 162, 162, 164, 162, 11, 164, 164, 164, 164, 164, - 164, 164, 164, 164, 164, 164, 164, 164, 164, 164, - 164, 164, 164, 164, 164, 164, 164, 164, 164, 164, - 164, 164, 164, 164, 164, 164, 164, 164, 164, 164, - 164, 164, 164, 164, 164, 164 + 25, 28, 28, 171, 28, 28, 34, 29, 29, 28, + 30, 153, 28, 35, 36, 29, 34, 73, 34, 31, + 152, 78, 37, 35, 36, 35, 87, 34, 73, 32, + 32, 37, 78, 92, 35, 46, 46, 87, 46, 47, + 32, 32, 41, 48, 92, 41, 53, 54, 56, 53, + 137, 56, 71, 72, 57, 71, 74, 75, 76, 53, + + 54, 77, 53, 42, 43, 136, 44, 74, 75, 76, + 45, 117, 77, 83, 42, 43, 83, 44, 162, 162, + 116, 45, 38, 46, 46, 95, 46, 47, 93, 38, + 38, 48, 68, 38, 94, 55, 38, 84, 38, 93, + 38, 38, 80, 46, 86, 80, 81, 86, 84, 40, + 82, 70, 38, 55, 38, 58, 59, 56, 58, 65, + 56, 38, 38, 57, 51, 38, 96, 59, 38, 96, + 38, 50, 38, 38, 97, 90, 60, 61, 91, 62, + 63, 88, 89, 64, 38, 38, 90, 60, 61, 91, + 62, 63, 88, 89, 64, 66, 98, 68, 71, 72, + + 49, 71, 66, 66, 101, 102, 66, 98, 66, 66, + 103, 66, 104, 66, 66, 101, 102, 86, 40, 172, + 86, 103, 30, 104, 172, 66, 66, 67, 67, 68, + 67, 67, 67, 67, 67, 67, 67, 67, 67, 67, + 69, 67, 67, 67, 67, 67, 67, 69, 69, 69, + 69, 69, 69, 69, 69, 69, 69, 67, 69, 69, + 69, 69, 69, 69, 69, 69, 69, 69, 41, 99, + 105, 41, 100, 106, 80, 46, 86, 80, 81, 86, + 99, 105, 82, 100, 106, 172, 172, 172, 85, 42, + 43, 172, 44, 107, 80, 46, 45, 80, 81, 172, + + 42, 43, 82, 44, 107, 172, 172, 45, 58, 80, + 46, 58, 80, 81, 172, 80, 46, 82, 80, 81, + 85, 172, 83, 82, 108, 83, 110, 109, 113, 60, + 61, 114, 62, 63, 115, 108, 64, 110, 109, 113, + 60, 61, 114, 62, 63, 115, 84, 64, 66, 111, + 68, 172, 118, 172, 112, 66, 66, 84, 119, 66, + 111, 66, 66, 118, 66, 112, 66, 66, 96, 119, + 120, 96, 121, 122, 123, 124, 97, 125, 66, 66, + 126, 120, 127, 121, 122, 123, 124, 128, 125, 129, + 130, 126, 131, 127, 132, 133, 134, 135, 128, 138, + + 129, 130, 139, 131, 140, 132, 133, 134, 135, 141, + 138, 142, 143, 139, 144, 140, 145, 146, 147, 148, + 141, 149, 142, 143, 151, 144, 154, 145, 146, 147, + 148, 150, 149, 155, 150, 151, 156, 154, 157, 158, + 159, 160, 150, 85, 155, 150, 164, 156, 165, 157, + 158, 159, 160, 166, 85, 167, 172, 164, 168, 165, + 168, 168, 172, 168, 166, 172, 167, 172, 172, 172, + 172, 172, 172, 169, 172, 169, 33, 33, 33, 33, + 33, 33, 33, 38, 172, 172, 172, 38, 38, 39, + 39, 39, 39, 39, 39, 39, 52, 172, 52, 67, + + 67, 67, 67, 67, 67, 67, 79, 79, 79, 79, + 79, 79, 79, 161, 161, 161, 172, 161, 161, 161, + 163, 172, 163, 172, 163, 163, 163, 170, 170, 170, + 170, 170, 172, 170, 11, 172, 172, 172, 172, 172, + 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, + 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, + 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, + 172, 172, 172, 172, 172, 172 } ; -static yyconst flex_int16_t yy_chk[547] = +static yyconst flex_int16_t yy_chk[577] = { 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 2, 4, 162, 2, 4, 7, 2, 4, 6, - 6, 130, 6, 7, 7, 6, 8, 42, 9, 6, - 129, 45, 9, 8, 8, 9, 59, 10, 42, 6, - 6, 10, 45, 62, 10, 18, 18, 59, 18, 18, - 6, 6, 17, 18, 62, 17, 26, 26, 28, 26, - 111, 28, 35, 35, 28, 35, 43, 43, 44, 53, - - 53, 44, 53, 17, 17, 110, 17, 43, 43, 44, - 17, 90, 44, 51, 17, 17, 51, 17, 144, 144, - 89, 17, 27, 46, 46, 68, 46, 46, 71, 27, - 27, 46, 65, 27, 63, 27, 27, 51, 27, 71, - 27, 27, 47, 47, 39, 47, 47, 34, 51, 30, - 47, 73, 27, 27, 29, 56, 24, 29, 56, 60, - 60, 56, 73, 61, 69, 69, 61, 69, 75, 23, - 60, 60, 21, 15, 61, 29, 29, 61, 29, 75, - 70, 72, 29, 70, 72, 11, 29, 29, 70, 29, - 5, 0, 72, 29, 31, 72, 31, 0, 74, 0, - - 76, 31, 31, 74, 0, 31, 82, 31, 31, 74, - 31, 76, 31, 31, 74, 77, 77, 82, 77, 77, - 0, 0, 0, 77, 31, 31, 32, 32, 32, 32, + 1, 2, 4, 170, 2, 4, 7, 2, 4, 6, + 6, 137, 6, 7, 7, 6, 8, 42, 9, 6, + 136, 45, 9, 8, 8, 9, 60, 10, 42, 6, + 6, 10, 45, 63, 10, 18, 18, 60, 18, 18, + 6, 6, 17, 18, 63, 17, 26, 26, 28, 26, + 117, 28, 35, 35, 28, 35, 43, 43, 44, 53, + + 53, 44, 53, 17, 17, 116, 17, 43, 43, 44, + 17, 95, 44, 51, 17, 17, 51, 17, 152, 152, + 94, 17, 27, 46, 46, 70, 46, 46, 64, 27, + 27, 46, 67, 27, 65, 27, 27, 51, 27, 64, + 27, 27, 47, 47, 59, 47, 47, 59, 51, 39, + 47, 34, 27, 27, 29, 29, 59, 56, 29, 30, + 56, 29, 29, 56, 24, 29, 72, 29, 29, 72, + 29, 23, 29, 29, 72, 62, 29, 29, 62, 29, + 29, 61, 61, 29, 29, 29, 62, 29, 29, 62, + 29, 29, 61, 61, 29, 31, 73, 31, 71, 71, + + 21, 71, 31, 31, 75, 76, 31, 73, 31, 31, + 76, 31, 77, 31, 31, 75, 76, 86, 15, 11, + 86, 76, 5, 77, 0, 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, - 32, 32, 32, 32, 32, 32, 32, 41, 78, 78, - 41, 78, 78, 83, 79, 79, 78, 79, 79, 85, - 81, 0, 79, 81, 83, 0, 0, 86, 41, 41, - 85, 41, 86, 80, 80, 41, 80, 80, 86, 41, - - 41, 80, 41, 86, 81, 84, 41, 57, 84, 87, - 57, 88, 93, 94, 95, 81, 84, 0, 91, 84, - 87, 91, 88, 93, 94, 95, 91, 96, 57, 57, - 97, 57, 98, 99, 100, 57, 0, 101, 96, 57, - 57, 97, 57, 98, 99, 100, 57, 64, 101, 64, - 0, 102, 0, 103, 64, 64, 104, 105, 64, 106, - 64, 64, 102, 64, 103, 64, 64, 104, 105, 107, - 106, 108, 109, 112, 115, 116, 117, 64, 64, 118, - 107, 119, 108, 109, 112, 115, 116, 117, 120, 121, - 118, 124, 119, 125, 126, 127, 128, 131, 134, 120, - - 121, 135, 124, 137, 125, 126, 127, 128, 131, 134, - 138, 141, 135, 142, 137, 148, 149, 152, 157, 0, - 158, 138, 141, 158, 142, 0, 148, 149, 152, 157, - 160, 0, 0, 160, 0, 158, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 160, 165, 165, 165, 165, - 165, 165, 165, 166, 0, 0, 0, 166, 166, 167, - 167, 167, 167, 167, 167, 167, 168, 0, 168, 169, - 169, 169, 169, 169, 169, 169, 170, 170, 170, 170, - 170, 170, 170, 171, 171, 171, 0, 171, 171, 171, - 172, 0, 172, 0, 172, 172, 172, 173, 173, 173, - - 173, 173, 0, 173, 164, 164, 164, 164, 164, 164, - 164, 164, 164, 164, 164, 164, 164, 164, 164, 164, - 164, 164, 164, 164, 164, 164, 164, 164, 164, 164, - 164, 164, 164, 164, 164, 164, 164, 164, 164, 164, - 164, 164, 164, 164, 164, 164 + 32, 32, 32, 32, 32, 32, 32, 32, 41, 74, + 78, 41, 74, 84, 79, 79, 85, 79, 79, 85, + 74, 78, 79, 74, 84, 0, 0, 0, 85, 41, + 41, 0, 41, 87, 80, 80, 41, 80, 80, 0, + + 41, 41, 80, 41, 87, 0, 0, 41, 57, 81, + 81, 57, 81, 81, 0, 82, 82, 81, 82, 82, + 57, 0, 83, 82, 88, 83, 89, 88, 91, 57, + 57, 92, 57, 57, 93, 88, 57, 89, 88, 91, + 57, 57, 92, 57, 57, 93, 83, 57, 66, 90, + 66, 0, 98, 0, 90, 66, 66, 83, 99, 66, + 90, 66, 66, 98, 66, 90, 66, 66, 96, 99, + 100, 96, 101, 102, 103, 104, 96, 105, 66, 66, + 106, 100, 107, 101, 102, 103, 104, 108, 105, 109, + 110, 106, 111, 107, 112, 113, 114, 115, 108, 118, + + 109, 110, 121, 111, 122, 112, 113, 114, 115, 123, + 118, 124, 125, 121, 126, 122, 127, 130, 131, 132, + 123, 133, 124, 125, 135, 126, 138, 127, 130, 131, + 132, 134, 133, 141, 134, 135, 142, 138, 144, 145, + 148, 149, 150, 134, 141, 150, 156, 142, 157, 144, + 145, 148, 149, 160, 150, 165, 0, 156, 166, 157, + 168, 166, 0, 168, 160, 0, 165, 0, 0, 0, + 0, 0, 0, 166, 0, 168, 173, 173, 173, 173, + 173, 173, 173, 174, 0, 0, 0, 174, 174, 175, + 175, 175, 175, 175, 175, 175, 176, 0, 176, 177, + + 177, 177, 177, 177, 177, 177, 178, 178, 178, 178, + 178, 178, 178, 179, 179, 179, 0, 179, 179, 179, + 180, 0, 180, 0, 180, 180, 180, 181, 181, 181, + 181, 181, 0, 181, 172, 172, 172, 172, 172, 172, + 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, + 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, + 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, + 172, 172, 172, 172, 172, 172 } ; /* The intent behind this definition is that it'll catch @@ -655,6 +665,7 @@ Run flex like this: Modify cmFortranLexer.cxx: - remove TABs + - remove use of the 'register' storage class specifier - remove "yyscanner" argument from these methods: yy_fatal_error, cmFortran_yyalloc, cmFortran_yyrealloc, cmFortran_yyfree - remove "yyscanner = NULL" from end of cmFortran_yylex_destroy @@ -685,7 +696,7 @@ Modify cmFortranLexer.h: /*--------------------------------------------------------------------------*/ -#line 678 "cmFortranLexer.cxx" +#line 689 "cmFortranLexer.cxx" #define INITIAL 0 #define free_fmt 1 @@ -718,8 +729,8 @@ struct yyguts_t size_t yy_buffer_stack_max; /**< capacity of stack. */ YY_BUFFER_STATE * yy_buffer_stack; /**< Stack as an array. */ char yy_hold_char; - int yy_n_chars; - int yyleng_r; + yy_size_t yy_n_chars; + yy_size_t yyleng_r; char *yy_c_buf_p; int yy_init; int yy_start; @@ -766,7 +777,7 @@ FILE *cmFortran_yyget_out (yyscan_t yyscanner ); void cmFortran_yyset_out (FILE * out_str ,yyscan_t yyscanner ); -int cmFortran_yyget_leng (yyscan_t yyscanner ); +yy_size_t cmFortran_yyget_leng (yyscan_t yyscanner ); char *cmFortran_yyget_text (yyscan_t yyscanner ); @@ -774,6 +785,10 @@ int cmFortran_yyget_lineno (yyscan_t yyscanner ); void cmFortran_yyset_lineno (int line_number ,yyscan_t yyscanner ); +int cmFortran_yyget_column (yyscan_t yyscanner ); + +void cmFortran_yyset_column (int column_no ,yyscan_t yyscanner ); + /* Macros after this point can all be overridden by user definitions in * section 1. */ @@ -918,11 +933,6 @@ YY_DECL int yy_act; struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; -#line 71 "cmFortranLexer.in.l" - - -#line 914 "cmFortranLexer.cxx" - if ( !yyg->yy_init ) { yyg->yy_init = 1; @@ -949,6 +959,12 @@ YY_DECL cmFortran_yy_load_buffer_state(yyscanner ); } + { +#line 72 "cmFortranLexer.in.l" + + +#line 956 "cmFortranLexer.cxx" + for(;;) /* loops until end-of-file is reached */ { yy_cp = yyg->yy_c_buf_p; @@ -966,7 +982,7 @@ YY_DECL yy_match: do { - YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)]; + YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ; if ( yy_accept[yy_current_state] ) { yyg->yy_last_accepting_state = yy_current_state; @@ -975,13 +991,13 @@ yy_match: while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) { yy_current_state = (int) yy_def[yy_current_state]; - if ( yy_current_state >= 165 ) + if ( yy_current_state >= 173 ) yy_c = yy_meta[(unsigned int) yy_c]; } yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; ++yy_cp; } - while ( yy_base[yy_current_state] != 505 ); + while ( yy_base[yy_current_state] != 535 ); yy_find_action: yy_act = yy_accept[yy_current_state]; @@ -1007,7 +1023,7 @@ do_action: /* This label is used only to access EOF actions. */ case 1: YY_RULE_SETUP -#line 73 "cmFortranLexer.in.l" +#line 74 "cmFortranLexer.in.l" { cmFortranParser_StringStart(yyextra); cmFortranParser_SetOldStartcond(yyextra, YY_START); @@ -1016,7 +1032,7 @@ YY_RULE_SETUP YY_BREAK case 2: YY_RULE_SETUP -#line 79 "cmFortranLexer.in.l" +#line 80 "cmFortranLexer.in.l" { cmFortranParser_StringStart(yyextra); cmFortranParser_SetOldStartcond(yyextra, YY_START); @@ -1024,10 +1040,10 @@ YY_RULE_SETUP } YY_BREAK case 3: -#line 86 "cmFortranLexer.in.l" +#line 87 "cmFortranLexer.in.l" case 4: YY_RULE_SETUP -#line 86 "cmFortranLexer.in.l" +#line 87 "cmFortranLexer.in.l" { BEGIN(cmFortranParser_GetOldStartcond(yyextra) ); yylvalp->string = strdup(cmFortranParser_StringEnd(yyextra)); @@ -1035,17 +1051,17 @@ YY_RULE_SETUP } case 5: /* rule 5 can match eol */ -#line 93 "cmFortranLexer.in.l" +#line 94 "cmFortranLexer.in.l" case 6: /* rule 6 can match eol */ YY_RULE_SETUP -#line 93 "cmFortranLexer.in.l" +#line 94 "cmFortranLexer.in.l" /* Ignore (continued strings, free fmt) */ YY_BREAK case 7: /* rule 7 can match eol */ YY_RULE_SETUP -#line 95 "cmFortranLexer.in.l" +#line 96 "cmFortranLexer.in.l" { if (cmFortranParser_GetOldStartcond(yyextra) == fixed_fmt) ; /* Ignore (cont. strings, fixed fmt) */ @@ -1058,7 +1074,7 @@ YY_RULE_SETUP case 8: /* rule 8 can match eol */ YY_RULE_SETUP -#line 105 "cmFortranLexer.in.l" +#line 106 "cmFortranLexer.in.l" { unput ('\n'); BEGIN(INITIAL); @@ -1066,7 +1082,7 @@ YY_RULE_SETUP } case 9: YY_RULE_SETUP -#line 111 "cmFortranLexer.in.l" +#line 112 "cmFortranLexer.in.l" { cmFortranParser_StringAppend(yyextra, yytext[0]); } @@ -1074,165 +1090,169 @@ YY_RULE_SETUP case 10: /* rule 10 can match eol */ YY_RULE_SETUP -#line 115 "cmFortranLexer.in.l" +#line 116 "cmFortranLexer.in.l" { return EOSTMT; } /* Treat comments like */ case 11: /* rule 11 can match eol */ YY_RULE_SETUP -#line 116 "cmFortranLexer.in.l" +#line 117 "cmFortranLexer.in.l" { return EOSTMT; } /* empty lines */ case 12: -/* rule 12 can match eol */ YY_RULE_SETUP -#line 118 "cmFortranLexer.in.l" +#line 119 "cmFortranLexer.in.l" +{ return CPP_LINE_DIRECTIVE; } +case 13: +/* rule 13 can match eol */ +YY_RULE_SETUP +#line 120 "cmFortranLexer.in.l" { yytext[yyleng-1] = 0; yylvalp->string = strdup(strchr(yytext, '<')+1); return CPP_INCLUDE_ANGLE; } -case 13: -YY_RULE_SETUP -#line 123 "cmFortranLexer.in.l" -{ return CPP_INCLUDE; } case 14: YY_RULE_SETUP -#line 124 "cmFortranLexer.in.l" -{ return F90PPR_INCLUDE; } +#line 125 "cmFortranLexer.in.l" +{ return CPP_INCLUDE; } case 15: YY_RULE_SETUP -#line 125 "cmFortranLexer.in.l" -{ return COCO_INCLUDE; } +#line 126 "cmFortranLexer.in.l" +{ return F90PPR_INCLUDE; } case 16: YY_RULE_SETUP #line 127 "cmFortranLexer.in.l" -{ return CPP_DEFINE; } +{ return COCO_INCLUDE; } case 17: YY_RULE_SETUP -#line 128 "cmFortranLexer.in.l" -{ return F90PPR_DEFINE; } +#line 129 "cmFortranLexer.in.l" +{ return CPP_DEFINE; } case 18: YY_RULE_SETUP #line 130 "cmFortranLexer.in.l" -{ return CPP_UNDEF; } +{ return F90PPR_DEFINE; } case 19: YY_RULE_SETUP -#line 131 "cmFortranLexer.in.l" -{ return F90PPR_UNDEF; } +#line 132 "cmFortranLexer.in.l" +{ return CPP_UNDEF; } case 20: YY_RULE_SETUP #line 133 "cmFortranLexer.in.l" -{ return CPP_IFDEF; } +{ return F90PPR_UNDEF; } case 21: YY_RULE_SETUP -#line 134 "cmFortranLexer.in.l" -{ return CPP_IFNDEF; } +#line 135 "cmFortranLexer.in.l" +{ return CPP_IFDEF; } case 22: YY_RULE_SETUP -#line 135 "cmFortranLexer.in.l" -{ return CPP_IF; } +#line 136 "cmFortranLexer.in.l" +{ return CPP_IFNDEF; } case 23: YY_RULE_SETUP -#line 136 "cmFortranLexer.in.l" -{ return CPP_ELIF; } +#line 137 "cmFortranLexer.in.l" +{ return CPP_IF; } case 24: YY_RULE_SETUP -#line 137 "cmFortranLexer.in.l" -{ return CPP_ELSE; } +#line 138 "cmFortranLexer.in.l" +{ return CPP_ELIF; } case 25: YY_RULE_SETUP -#line 138 "cmFortranLexer.in.l" -{ return CPP_ENDIF; } +#line 139 "cmFortranLexer.in.l" +{ return CPP_ELSE; } case 26: YY_RULE_SETUP #line 140 "cmFortranLexer.in.l" -{ return F90PPR_IFDEF; } +{ return CPP_ENDIF; } case 27: YY_RULE_SETUP -#line 141 "cmFortranLexer.in.l" -{ return F90PPR_IFNDEF; } +#line 142 "cmFortranLexer.in.l" +{ return F90PPR_IFDEF; } case 28: YY_RULE_SETUP -#line 142 "cmFortranLexer.in.l" -{ return F90PPR_IF; } +#line 143 "cmFortranLexer.in.l" +{ return F90PPR_IFNDEF; } case 29: YY_RULE_SETUP -#line 143 "cmFortranLexer.in.l" -{ return F90PPR_ELIF; } +#line 144 "cmFortranLexer.in.l" +{ return F90PPR_IF; } case 30: YY_RULE_SETUP -#line 144 "cmFortranLexer.in.l" -{ return F90PPR_ELSE; } +#line 145 "cmFortranLexer.in.l" +{ return F90PPR_ELIF; } case 31: YY_RULE_SETUP -#line 145 "cmFortranLexer.in.l" -{ return F90PPR_ENDIF; } -/* Line continuations, possible involving comments. */ +#line 146 "cmFortranLexer.in.l" +{ return F90PPR_ELSE; } case 32: -/* rule 32 can match eol */ YY_RULE_SETUP -#line 148 "cmFortranLexer.in.l" - - YY_BREAK +#line 147 "cmFortranLexer.in.l" +{ return F90PPR_ENDIF; } +/* Line continuations, possible involving comments. */ case 33: /* rule 33 can match eol */ YY_RULE_SETUP -#line 149 "cmFortranLexer.in.l" +#line 150 "cmFortranLexer.in.l" YY_BREAK case 34: +/* rule 34 can match eol */ YY_RULE_SETUP #line 151 "cmFortranLexer.in.l" -{ return COMMA; } + + YY_BREAK case 35: YY_RULE_SETUP #line 153 "cmFortranLexer.in.l" -{ return DCOLON; } +{ return COMMA; } case 36: -/* rule 36 can match eol */ YY_RULE_SETUP #line 155 "cmFortranLexer.in.l" -{ return GARBAGE; } +{ return DCOLON; } case 37: +/* rule 37 can match eol */ YY_RULE_SETUP #line 157 "cmFortranLexer.in.l" -{ return ASSIGNMENT_OP; } +{ return GARBAGE; } case 38: YY_RULE_SETUP #line 159 "cmFortranLexer.in.l" +{ return ASSIGNMENT_OP; } +case 39: +YY_RULE_SETUP +#line 161 "cmFortranLexer.in.l" { yylvalp->string = strdup(yytext); return WORD; } -case 39: -YY_RULE_SETUP -#line 164 "cmFortranLexer.in.l" -{ return GARBAGE; } case 40: -/* rule 40 can match eol */ YY_RULE_SETUP #line 166 "cmFortranLexer.in.l" -{ return EOSTMT; } +{ return GARBAGE; } case 41: +/* rule 41 can match eol */ YY_RULE_SETUP -#line 169 "cmFortranLexer.in.l" -/* Ignore */ - YY_BREAK +#line 168 "cmFortranLexer.in.l" +{ return EOSTMT; } case 42: -/* rule 42 can match eol */ YY_RULE_SETUP -#line 170 "cmFortranLexer.in.l" -/* Ignore line-endings preceeded by \ */ +#line 171 "cmFortranLexer.in.l" +/* Ignore */ YY_BREAK case 43: +/* rule 43 can match eol */ YY_RULE_SETUP #line 172 "cmFortranLexer.in.l" +/* Ignore line-endings preceeded by \ */ + YY_BREAK +case 44: +YY_RULE_SETUP +#line 174 "cmFortranLexer.in.l" { return *yytext; } case YY_STATE_EOF(INITIAL): case YY_STATE_EOF(free_fmt): case YY_STATE_EOF(fixed_fmt): case YY_STATE_EOF(str_sq): case YY_STATE_EOF(str_dq): -#line 174 "cmFortranLexer.in.l" +#line 176 "cmFortranLexer.in.l" { if(!cmFortranParser_FilePop(yyextra) ) { @@ -1240,12 +1260,12 @@ case YY_STATE_EOF(str_dq): } } YY_BREAK -case 44: +case 45: YY_RULE_SETUP -#line 181 "cmFortranLexer.in.l" +#line 183 "cmFortranLexer.in.l" ECHO; YY_BREAK -#line 1270 "cmFortranLexer.cxx" +#line 1291 "cmFortranLexer.cxx" case YY_END_OF_BUFFER: { @@ -1374,6 +1394,7 @@ ECHO; "fatal flex scanner internal error--no action found" ); } /* end of action switch */ } /* end of scanning one token */ + } /* end of user's declarations */ } /* end of cmFortran_yylex */ /* yy_get_next_buffer - try to read in a new buffer @@ -1430,21 +1451,21 @@ static int yy_get_next_buffer (yyscan_t yyscanner) else { - int num_to_read = + yy_size_t num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1; while ( num_to_read <= 0 ) { /* Not enough room in the buffer - grow it. */ /* just a shorter name for the current buffer */ - YY_BUFFER_STATE b = YY_CURRENT_BUFFER; + YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE; int yy_c_buf_p_offset = (int) (yyg->yy_c_buf_p - b->yy_ch_buf); if ( b->yy_is_our_buffer ) { - int new_size = b->yy_buf_size * 2; + yy_size_t new_size = b->yy_buf_size * 2; if ( new_size <= 0 ) b->yy_buf_size += b->yy_buf_size / 8; @@ -1475,7 +1496,7 @@ static int yy_get_next_buffer (yyscan_t yyscanner) /* Read in more data. */ YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]), - yyg->yy_n_chars, (size_t) num_to_read ); + yyg->yy_n_chars, num_to_read ); YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars; } @@ -1538,7 +1559,7 @@ static int yy_get_next_buffer (yyscan_t yyscanner) while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) { yy_current_state = (int) yy_def[yy_current_state]; - if ( yy_current_state >= 165 ) + if ( yy_current_state >= 173 ) yy_c = yy_meta[(unsigned int) yy_c]; } yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; @@ -1567,12 +1588,13 @@ static int yy_get_next_buffer (yyscan_t yyscanner) while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) { yy_current_state = (int) yy_def[yy_current_state]; - if ( yy_current_state >= 165 ) + if ( yy_current_state >= 173 ) yy_c = yy_meta[(unsigned int) yy_c]; } yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; - yy_is_jam = (yy_current_state == 164); + yy_is_jam = (yy_current_state == 172); + (void)yyg; return yy_is_jam ? 0 : yy_current_state; } @@ -1589,7 +1611,7 @@ static int yy_get_next_buffer (yyscan_t yyscanner) if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 ) { /* need to shift things up to make room */ /* +2 for EOB chars. */ - int number_to_move = yyg->yy_n_chars + 2; + yy_size_t number_to_move = yyg->yy_n_chars + 2; char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[ YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2]; char *source = @@ -1639,7 +1661,7 @@ static int yy_get_next_buffer (yyscan_t yyscanner) else { /* need more input */ - int offset = yyg->yy_c_buf_p - yyg->yytext_ptr; + yy_size_t offset = yyg->yy_c_buf_p - yyg->yytext_ptr; ++yyg->yy_c_buf_p; switch ( yy_get_next_buffer( yyscanner ) ) @@ -1805,10 +1827,6 @@ static void cmFortran_yy_load_buffer_state (yyscan_t yyscanner) cmFortran_yyfree((void *) b ,yyscanner ); } -#ifndef __cplusplus -extern int isatty (int ); -#endif /* __cplusplus */ - /* Initializes or reinitializes a buffer. * This function is sometimes called more than once on the same buffer, * such as during a cmFortran_yyrestart() or at EOF. @@ -1925,7 +1943,7 @@ void cmFortran_yypop_buffer_state (yyscan_t yyscanner) */ static void cmFortran_yyensure_buffer_stack (yyscan_t yyscanner) { - int num_to_alloc; + yy_size_t num_to_alloc; struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; if (!yyg->yy_buffer_stack) { @@ -2023,12 +2041,12 @@ YY_BUFFER_STATE cmFortran_yy_scan_string (yyconst char * yystr , yyscan_t yyscan * @param yyscanner The scanner object. * @return the newly allocated buffer state object. */ -YY_BUFFER_STATE cmFortran_yy_scan_bytes (yyconst char * yybytes, int _yybytes_len , yyscan_t yyscanner) +YY_BUFFER_STATE cmFortran_yy_scan_bytes (yyconst char * yybytes, yy_size_t _yybytes_len , yyscan_t yyscanner) { YY_BUFFER_STATE b; char *buf; yy_size_t n; - int i; + yy_size_t i; /* Get memory for full buffer, including space for trailing EOB's. */ n = _yybytes_len + 2; @@ -2138,7 +2156,7 @@ FILE *cmFortran_yyget_out (yyscan_t yyscanner) /** Get the length of the current token. * @param yyscanner The scanner object. */ -int cmFortran_yyget_leng (yyscan_t yyscanner) +yy_size_t cmFortran_yyget_leng (yyscan_t yyscanner) { struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; return yyleng; @@ -2174,7 +2192,7 @@ void cmFortran_yyset_lineno (int line_number , yyscan_t yyscanner) /* lineno is only valid if an input buffer exists. */ if (! YY_CURRENT_BUFFER ) - yy_fatal_error( "cmFortran_yyset_lineno called with no buffer" , yyscanner); + YY_FATAL_ERROR( "cmFortran_yyset_lineno called with no buffer" ); yylineno = line_number; } @@ -2189,7 +2207,7 @@ void cmFortran_yyset_column (int column_no , yyscan_t yyscanner) /* column is only valid if an input buffer exists. */ if (! YY_CURRENT_BUFFER ) - yy_fatal_error( "cmFortran_yyset_column called with no buffer" , yyscanner); + YY_FATAL_ERROR( "cmFortran_yyset_column called with no buffer" ); yycolumn = column_no; } @@ -2400,7 +2418,7 @@ void cmFortran_yyfree (void * ptr , yyscan_t) #define YYTABLES_NAME "yytables" -#line 181 "cmFortranLexer.in.l" +#line 182 "cmFortranLexer.in.l" diff --git a/Source/cmFortranLexer.h b/Source/cmFortranLexer.h index c67e332..b9ff0dc 100644 --- a/Source/cmFortranLexer.h +++ b/Source/cmFortranLexer.h @@ -1,6 +1,6 @@ /*============================================================================ CMake - Cross Platform Makefile Generator - Copyright 2000-2009 Kitware, Inc., Insight Software Consortium + Copyright 2000-2015 Kitware, Inc., Insight Software Consortium Distributed under the OSI-approved BSD License (the "License"); see accompanying file Copyright.txt for details. @@ -20,7 +20,7 @@ #define FLEX_SCANNER #define YY_FLEX_MAJOR_VERSION 2 #define YY_FLEX_MINOR_VERSION 5 -#define YY_FLEX_SUBMINOR_VERSION 35 +#define YY_FLEX_SUBMINOR_VERSION 39 #if YY_FLEX_SUBMINOR_VERSION > 0 #define FLEX_BETA #endif @@ -177,7 +177,7 @@ struct yy_buffer_state /* Number of characters read into yy_ch_buf, not including EOB * characters. */ - int yy_n_chars; + yy_size_t yy_n_chars; /* Whether we "own" the buffer - i.e., we know we created it, * and can realloc() it to grow it, and should free() it to @@ -221,7 +221,7 @@ void cmFortran_yypop_buffer_state (yyscan_t yyscanner ); YY_BUFFER_STATE cmFortran_yy_scan_buffer (char *base,yy_size_t size ,yyscan_t yyscanner ); YY_BUFFER_STATE cmFortran_yy_scan_string (yyconst char *yy_str ,yyscan_t yyscanner ); -YY_BUFFER_STATE cmFortran_yy_scan_bytes (yyconst char *bytes,int len ,yyscan_t yyscanner ); +YY_BUFFER_STATE cmFortran_yy_scan_bytes (yyconst char *bytes,yy_size_t len ,yyscan_t yyscanner ); void *cmFortran_yyalloc (yy_size_t ,yyscan_t yyscanner ); void *cmFortran_yyrealloc (void *,yy_size_t ,yyscan_t yyscanner ); @@ -229,7 +229,7 @@ void cmFortran_yyfree (void * ,yyscan_t yyscanner ); /* Begin user sect3 */ -#define cmFortran_yywrap(n) 1 +#define cmFortran_yywrap(yyscanner) 1 #define YY_SKIP_YYWRAP #define yytext_ptr yytext_r @@ -272,7 +272,7 @@ FILE *cmFortran_yyget_out (yyscan_t yyscanner ); void cmFortran_yyset_out (FILE * out_str ,yyscan_t yyscanner ); -int cmFortran_yyget_leng (yyscan_t yyscanner ); +yy_size_t cmFortran_yyget_leng (yyscan_t yyscanner ); char *cmFortran_yyget_text (yyscan_t yyscanner ); @@ -280,6 +280,10 @@ int cmFortran_yyget_lineno (yyscan_t yyscanner ); void cmFortran_yyset_lineno (int line_number ,yyscan_t yyscanner ); +int cmFortran_yyget_column (yyscan_t yyscanner ); + +void cmFortran_yyset_column (int column_no ,yyscan_t yyscanner ); + /* Macros after this point can all be overridden by user definitions in * section 1. */ diff --git a/Source/cmFortranLexer.in.l b/Source/cmFortranLexer.in.l index 03fa90c..53984bb 100644 --- a/Source/cmFortranLexer.in.l +++ b/Source/cmFortranLexer.in.l @@ -1,7 +1,7 @@ %{ /*============================================================================ CMake - Cross Platform Makefile Generator - Copyright 2000-2009 Kitware, Inc., Insight Software Consortium + Copyright 2000-2015 Kitware, Inc., Insight Software Consortium Distributed under the OSI-approved BSD License (the "License"); see accompanying file Copyright.txt for details. @@ -116,6 +116,7 @@ Modify cmFortranLexer.h: !.*\n { return EOSTMT; } /* Treat comments like */ <fixed_fmt>^[cC*dD].*\n { return EOSTMT; } /* empty lines */ +^[ \t]*#([ \t]*line)?[ \t]*[0-9]+[ \t]* { return CPP_LINE_DIRECTIVE; } ^[ \t]*#[ \t]*include[ \t]*<[^>]+> { yytext[yyleng-1] = 0; yylvalp->string = strdup(strchr(yytext, '<')+1); diff --git a/Source/cmFortranParser.cxx b/Source/cmFortranParser.cxx index 0230f02..21a6443 100644 --- a/Source/cmFortranParser.cxx +++ b/Source/cmFortranParser.cxx @@ -72,7 +72,7 @@ /*============================================================================ CMake - Cross Platform Makefile Generator - Copyright 2000-2009 Kitware, Inc., Insight Software Consortium + Copyright 2000-2015 Kitware, Inc., Insight Software Consortium Distributed under the OSI-approved BSD License (the "License"); see accompanying file Copyright.txt for details. @@ -177,64 +177,66 @@ extern int cmFortran_yydebug; EOSTMT = 258, ASSIGNMENT_OP = 259, GARBAGE = 260, - CPP_INCLUDE = 261, - F90PPR_INCLUDE = 262, - COCO_INCLUDE = 263, - F90PPR_DEFINE = 264, - CPP_DEFINE = 265, - F90PPR_UNDEF = 266, - CPP_UNDEF = 267, - CPP_IFDEF = 268, - CPP_IFNDEF = 269, - CPP_IF = 270, - CPP_ELSE = 271, - CPP_ELIF = 272, - CPP_ENDIF = 273, - F90PPR_IFDEF = 274, - F90PPR_IFNDEF = 275, - F90PPR_IF = 276, - F90PPR_ELSE = 277, - F90PPR_ELIF = 278, - F90PPR_ENDIF = 279, - COMMA = 280, - DCOLON = 281, - CPP_TOENDL = 282, - UNTERMINATED_STRING = 283, - STRING = 284, - WORD = 285, - CPP_INCLUDE_ANGLE = 286 + CPP_LINE_DIRECTIVE = 261, + CPP_INCLUDE = 262, + F90PPR_INCLUDE = 263, + COCO_INCLUDE = 264, + F90PPR_DEFINE = 265, + CPP_DEFINE = 266, + F90PPR_UNDEF = 267, + CPP_UNDEF = 268, + CPP_IFDEF = 269, + CPP_IFNDEF = 270, + CPP_IF = 271, + CPP_ELSE = 272, + CPP_ELIF = 273, + CPP_ENDIF = 274, + F90PPR_IFDEF = 275, + F90PPR_IFNDEF = 276, + F90PPR_IF = 277, + F90PPR_ELSE = 278, + F90PPR_ELIF = 279, + F90PPR_ENDIF = 280, + COMMA = 281, + DCOLON = 282, + CPP_TOENDL = 283, + UNTERMINATED_STRING = 284, + STRING = 285, + WORD = 286, + CPP_INCLUDE_ANGLE = 287 }; #endif /* Tokens. */ #define EOSTMT 258 #define ASSIGNMENT_OP 259 #define GARBAGE 260 -#define CPP_INCLUDE 261 -#define F90PPR_INCLUDE 262 -#define COCO_INCLUDE 263 -#define F90PPR_DEFINE 264 -#define CPP_DEFINE 265 -#define F90PPR_UNDEF 266 -#define CPP_UNDEF 267 -#define CPP_IFDEF 268 -#define CPP_IFNDEF 269 -#define CPP_IF 270 -#define CPP_ELSE 271 -#define CPP_ELIF 272 -#define CPP_ENDIF 273 -#define F90PPR_IFDEF 274 -#define F90PPR_IFNDEF 275 -#define F90PPR_IF 276 -#define F90PPR_ELSE 277 -#define F90PPR_ELIF 278 -#define F90PPR_ENDIF 279 -#define COMMA 280 -#define DCOLON 281 -#define CPP_TOENDL 282 -#define UNTERMINATED_STRING 283 -#define STRING 284 -#define WORD 285 -#define CPP_INCLUDE_ANGLE 286 +#define CPP_LINE_DIRECTIVE 261 +#define CPP_INCLUDE 262 +#define F90PPR_INCLUDE 263 +#define COCO_INCLUDE 264 +#define F90PPR_DEFINE 265 +#define CPP_DEFINE 266 +#define F90PPR_UNDEF 267 +#define CPP_UNDEF 268 +#define CPP_IFDEF 269 +#define CPP_IFNDEF 270 +#define CPP_IF 271 +#define CPP_ELSE 272 +#define CPP_ELIF 273 +#define CPP_ENDIF 274 +#define F90PPR_IFDEF 275 +#define F90PPR_IFNDEF 276 +#define F90PPR_IF 277 +#define F90PPR_ELSE 278 +#define F90PPR_ELIF 279 +#define F90PPR_ENDIF 280 +#define COMMA 281 +#define DCOLON 282 +#define CPP_TOENDL 283 +#define UNTERMINATED_STRING 284 +#define STRING 285 +#define WORD 286 +#define CPP_INCLUDE_ANGLE 287 /* Value type. */ #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED @@ -245,7 +247,7 @@ union YYSTYPE char* string; -#line 249 "cmFortranParser.cxx" /* yacc.c:355 */ +#line 251 "cmFortranParser.cxx" /* yacc.c:355 */ }; # define YYSTYPE_IS_TRIVIAL 1 # define YYSTYPE_IS_DECLARED 1 @@ -259,7 +261,7 @@ int cmFortran_yyparse (yyscan_t yyscanner); /* Copy the second part of user declarations. */ -#line 263 "cmFortranParser.cxx" /* yacc.c:358 */ +#line 265 "cmFortranParser.cxx" /* yacc.c:358 */ #ifdef short # undef short @@ -501,21 +503,21 @@ union yyalloc /* YYFINAL -- State number of the termination state. */ #define YYFINAL 2 /* YYLAST -- Last index in YYTABLE. */ -#define YYLAST 276 +#define YYLAST 290 /* YYNTOKENS -- Number of terminals. */ -#define YYNTOKENS 32 +#define YYNTOKENS 33 /* YYNNTS -- Number of nonterminals. */ #define YYNNTS 16 /* YYNRULES -- Number of rules. */ -#define YYNRULES 53 +#define YYNRULES 54 /* YYNSTATES -- Number of states. */ -#define YYNSTATES 97 +#define YYNSTATES 101 /* YYTRANSLATE[YYX] -- Symbol number corresponding to YYX as returned by yylex, with out-of-bounds checking. */ #define YYUNDEFTOK 2 -#define YYMAXUTOK 286 +#define YYMAXUTOK 287 #define YYTRANSLATE(YYX) \ ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) @@ -552,19 +554,19 @@ static const yytype_uint8 yytranslate[] = 2, 2, 2, 2, 2, 2, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, - 25, 26, 27, 28, 29, 30, 31 + 25, 26, 27, 28, 29, 30, 31, 32 }; #if YYDEBUG /* YYRLINE[YYN] -- Source line where rule number YYN was defined. */ static const yytype_uint16 yyrline[] = { - 0, 103, 103, 103, 105, 105, 107, 113, 123, 153, - 164, 177, 188, 195, 202, 208, 214, 220, 226, 231, - 236, 241, 246, 250, 251, 252, 257, 257, 257, 258, - 258, 259, 259, 260, 260, 261, 261, 262, 262, 263, - 263, 264, 264, 265, 265, 266, 266, 269, 270, 271, - 272, 273, 274, 275 + 0, 104, 104, 104, 106, 106, 108, 114, 124, 154, + 165, 178, 189, 196, 203, 210, 216, 222, 228, 234, + 239, 244, 249, 254, 258, 259, 260, 265, 265, 265, + 266, 266, 267, 267, 268, 268, 269, 269, 270, 270, + 271, 271, 272, 272, 273, 273, 274, 274, 277, 278, + 279, 280, 281, 282, 283 }; #endif @@ -574,14 +576,15 @@ static const yytype_uint16 yyrline[] = static const char *const yytname[] = { "$end", "error", "$undefined", "EOSTMT", "ASSIGNMENT_OP", "GARBAGE", - "CPP_INCLUDE", "F90PPR_INCLUDE", "COCO_INCLUDE", "F90PPR_DEFINE", - "CPP_DEFINE", "F90PPR_UNDEF", "CPP_UNDEF", "CPP_IFDEF", "CPP_IFNDEF", - "CPP_IF", "CPP_ELSE", "CPP_ELIF", "CPP_ENDIF", "F90PPR_IFDEF", - "F90PPR_IFNDEF", "F90PPR_IF", "F90PPR_ELSE", "F90PPR_ELIF", - "F90PPR_ENDIF", "COMMA", "DCOLON", "CPP_TOENDL", "UNTERMINATED_STRING", - "STRING", "WORD", "CPP_INCLUDE_ANGLE", "$accept", "code", "stmt", - "assignment_stmt", "keyword_stmt", "include", "define", "undef", "ifdef", - "ifndef", "if", "elif", "else", "endif", "other", "misc_code", YY_NULLPTR + "CPP_LINE_DIRECTIVE", "CPP_INCLUDE", "F90PPR_INCLUDE", "COCO_INCLUDE", + "F90PPR_DEFINE", "CPP_DEFINE", "F90PPR_UNDEF", "CPP_UNDEF", "CPP_IFDEF", + "CPP_IFNDEF", "CPP_IF", "CPP_ELSE", "CPP_ELIF", "CPP_ENDIF", + "F90PPR_IFDEF", "F90PPR_IFNDEF", "F90PPR_IF", "F90PPR_ELSE", + "F90PPR_ELIF", "F90PPR_ENDIF", "COMMA", "DCOLON", "CPP_TOENDL", + "UNTERMINATED_STRING", "STRING", "WORD", "CPP_INCLUDE_ANGLE", "$accept", + "code", "stmt", "assignment_stmt", "keyword_stmt", "include", "define", + "undef", "ifdef", "ifndef", "if", "elif", "else", "endif", "other", + "misc_code", YY_NULLPTR }; #endif @@ -593,14 +596,14 @@ static const yytype_uint16 yytoknum[] = 0, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, - 285, 286 + 285, 286, 287 }; # endif -#define YYPACT_NINF -29 +#define YYPACT_NINF -30 #define yypact_value_is_default(Yystate) \ - (!!((Yystate) == (-29))) + (!!((Yystate) == (-30))) #define YYTABLE_NINF -1 @@ -611,16 +614,17 @@ static const yytype_uint16 yytoknum[] = STATE-NUM. */ static const yytype_int16 yypact[] = { - -29, 39, -29, -29, -29, -29, -29, -29, -29, -29, - -29, -29, -29, -29, -29, -29, -29, -29, -29, -29, - -29, -29, -29, -29, -29, 246, -29, -29, -29, -29, - -28, -27, -22, -17, -16, -29, -29, -29, -29, 2, - -29, -29, -29, -13, -12, -29, -29, 61, -29, -29, - -29, -29, -29, 68, 74, 80, 108, -29, -29, -29, - -29, -29, -29, -29, -29, -29, 114, 120, -24, -29, - 126, 154, -29, 160, 166, 172, 200, 206, -29, -29, - -29, -29, -29, -29, -9, 212, -29, -29, -29, -29, - -29, -29, -29, -29, -29, 218, -29 + -30, 41, -30, -30, -30, -30, -29, -30, -30, -30, + -30, -30, -30, -30, -30, -30, -30, -30, -30, -30, + -30, -30, -30, -30, -30, -30, 259, -30, -30, -30, + -30, -28, -23, -18, -16, -13, -30, -30, -30, -30, + 2, -30, -30, -30, -30, -12, -9, -30, -30, 64, + -30, -30, -30, -30, -30, 71, 77, 83, 112, -30, + -30, -30, -30, -30, -30, -30, -30, -30, 118, 124, + 130, -24, -30, 159, 165, -30, 171, 177, 206, 212, + 218, -30, -30, -30, -30, -30, -30, -30, -1, 224, + -30, -30, -30, -30, -30, -30, -30, -30, -30, 253, + -30 }; /* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM. @@ -628,30 +632,31 @@ static const yytype_int16 yypact[] = means the default is an error. */ static const yytype_uint8 yydefact[] = { - 2, 0, 1, 25, 24, 45, 26, 27, 28, 30, - 29, 32, 31, 33, 35, 37, 41, 39, 43, 34, - 36, 38, 42, 40, 44, 0, 45, 3, 5, 4, - 0, 0, 0, 0, 0, 45, 45, 45, 45, 0, - 7, 45, 45, 0, 0, 45, 45, 0, 45, 45, - 45, 45, 45, 0, 0, 0, 0, 23, 50, 49, - 52, 51, 53, 48, 47, 46, 0, 0, 0, 45, - 0, 0, 12, 0, 0, 0, 0, 0, 18, 19, - 20, 21, 6, 22, 0, 0, 11, 8, 13, 14, - 15, 16, 17, 45, 9, 0, 10 + 2, 0, 1, 26, 25, 46, 0, 27, 28, 29, + 31, 30, 33, 32, 34, 36, 38, 42, 40, 44, + 35, 37, 39, 43, 41, 45, 0, 46, 3, 5, + 4, 0, 0, 0, 0, 0, 46, 46, 46, 46, + 0, 46, 7, 46, 46, 0, 0, 46, 46, 0, + 46, 46, 46, 46, 46, 0, 0, 0, 0, 24, + 51, 50, 53, 52, 54, 49, 48, 47, 0, 0, + 0, 0, 46, 0, 0, 13, 0, 0, 0, 0, + 0, 19, 20, 21, 22, 12, 6, 23, 0, 0, + 11, 8, 14, 15, 16, 17, 18, 46, 9, 0, + 10 }; /* YYPGOTO[NTERM-NUM]. */ static const yytype_int8 yypgoto[] = { - -29, -29, -29, -29, -29, -29, -29, -29, -29, -29, - -29, -29, -29, -29, -26, -29 + -30, -30, -30, -30, -30, -30, -30, -30, -30, -30, + -30, -30, -30, -30, -27, -30 }; /* YYDEFGOTO[NTERM-NUM]. */ static const yytype_int8 yydefgoto[] = { - -1, 1, 27, 28, 29, 30, 31, 32, 33, 34, - 35, 36, 37, 38, 39, 65 + -1, 1, 28, 29, 30, 31, 32, 33, 34, 35, + 36, 37, 38, 39, 40, 67 }; /* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM. If @@ -659,104 +664,109 @@ static const yytype_int8 yydefgoto[] = number is the opposite. If YYTABLE_NINF, syntax error. */ static const yytype_uint8 yytable[] = { - 47, 48, 84, 49, 0, 57, 58, 59, 50, 53, - 54, 55, 56, 51, 52, 66, 67, 68, 69, 70, - 71, 93, 73, 74, 75, 76, 77, 60, 61, 0, - 62, 63, 64, 0, 0, 0, 0, 0, 0, 2, - 3, 0, 4, 85, 5, 6, 7, 8, 9, 10, - 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, - 21, 22, 23, 24, 72, 58, 59, 95, 0, 25, - 26, 78, 58, 59, 0, 0, 0, 79, 58, 59, - 0, 0, 0, 80, 58, 59, 60, 61, 0, 62, - 63, 64, 0, 60, 61, 0, 62, 63, 64, 60, - 61, 0, 62, 63, 64, 60, 61, 0, 62, 63, - 64, 81, 58, 59, 0, 0, 0, 82, 58, 59, - 0, 0, 0, 83, 58, 59, 0, 0, 0, 86, - 58, 59, 0, 60, 61, 0, 62, 63, 64, 60, - 61, 0, 62, 63, 64, 60, 61, 0, 62, 63, - 64, 60, 61, 0, 62, 63, 64, 87, 58, 59, - 0, 0, 0, 88, 58, 59, 0, 0, 0, 89, - 58, 59, 0, 0, 0, 90, 58, 59, 0, 60, - 61, 0, 62, 63, 64, 60, 61, 0, 62, 63, - 64, 60, 61, 0, 62, 63, 64, 60, 61, 0, - 62, 63, 64, 91, 58, 59, 0, 0, 0, 92, - 58, 59, 0, 0, 0, 94, 58, 59, 0, 0, - 0, 96, 58, 59, 0, 60, 61, 0, 62, 63, - 64, 60, 61, 0, 62, 63, 64, 60, 61, 0, - 62, 63, 64, 60, 61, 0, 62, 63, 64, 40, - 41, 42, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 43, 44, 0, 0, 45, 46 + 49, 41, 50, 88, 0, 59, 60, 61, 51, 55, + 56, 57, 58, 52, 68, 53, 69, 70, 54, 71, + 73, 74, 72, 76, 77, 78, 79, 80, 62, 63, + 97, 64, 65, 66, 0, 0, 0, 0, 0, 0, + 0, 2, 3, 0, 4, 89, 5, 6, 7, 8, + 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, + 19, 20, 21, 22, 23, 24, 25, 75, 60, 61, + 99, 0, 26, 27, 81, 60, 61, 0, 0, 0, + 82, 60, 61, 0, 0, 0, 83, 60, 61, 0, + 62, 63, 0, 64, 65, 66, 0, 62, 63, 0, + 64, 65, 66, 62, 63, 0, 64, 65, 66, 62, + 63, 0, 64, 65, 66, 84, 60, 61, 0, 0, + 0, 85, 60, 61, 0, 0, 0, 86, 60, 61, + 0, 0, 0, 87, 60, 61, 0, 0, 62, 63, + 0, 64, 65, 66, 62, 63, 0, 64, 65, 66, + 62, 63, 0, 64, 65, 66, 62, 63, 0, 64, + 65, 66, 90, 60, 61, 0, 0, 0, 91, 60, + 61, 0, 0, 0, 92, 60, 61, 0, 0, 0, + 93, 60, 61, 0, 0, 62, 63, 0, 64, 65, + 66, 62, 63, 0, 64, 65, 66, 62, 63, 0, + 64, 65, 66, 62, 63, 0, 64, 65, 66, 94, + 60, 61, 0, 0, 0, 95, 60, 61, 0, 0, + 0, 96, 60, 61, 0, 0, 0, 98, 60, 61, + 0, 0, 62, 63, 0, 64, 65, 66, 62, 63, + 0, 64, 65, 66, 62, 63, 0, 64, 65, 66, + 62, 63, 0, 64, 65, 66, 100, 60, 61, 0, + 0, 0, 42, 43, 44, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 62, + 63, 0, 64, 65, 66, 45, 46, 0, 0, 47, + 48 }; static const yytype_int8 yycheck[] = { - 26, 29, 26, 30, -1, 3, 4, 5, 30, 35, - 36, 37, 38, 30, 30, 41, 42, 30, 30, 45, - 46, 30, 48, 49, 50, 51, 52, 25, 26, -1, - 28, 29, 30, -1, -1, -1, -1, -1, -1, 0, - 1, -1, 3, 69, 5, 6, 7, 8, 9, 10, - 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, - 21, 22, 23, 24, 3, 4, 5, 93, -1, 30, - 31, 3, 4, 5, -1, -1, -1, 3, 4, 5, - -1, -1, -1, 3, 4, 5, 25, 26, -1, 28, - 29, 30, -1, 25, 26, -1, 28, 29, 30, 25, - 26, -1, 28, 29, 30, 25, 26, -1, 28, 29, - 30, 3, 4, 5, -1, -1, -1, 3, 4, 5, - -1, -1, -1, 3, 4, 5, -1, -1, -1, 3, - 4, 5, -1, 25, 26, -1, 28, 29, 30, 25, - 26, -1, 28, 29, 30, 25, 26, -1, 28, 29, - 30, 25, 26, -1, 28, 29, 30, 3, 4, 5, - -1, -1, -1, 3, 4, 5, -1, -1, -1, 3, - 4, 5, -1, -1, -1, 3, 4, 5, -1, 25, - 26, -1, 28, 29, 30, 25, 26, -1, 28, 29, - 30, 25, 26, -1, 28, 29, 30, 25, 26, -1, - 28, 29, 30, 3, 4, 5, -1, -1, -1, 3, + 27, 30, 30, 27, -1, 3, 4, 5, 31, 36, + 37, 38, 39, 31, 41, 31, 43, 44, 31, 31, + 47, 48, 31, 50, 51, 52, 53, 54, 26, 27, + 31, 29, 30, 31, -1, -1, -1, -1, -1, -1, + -1, 0, 1, -1, 3, 72, 5, 6, 7, 8, + 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, + 19, 20, 21, 22, 23, 24, 25, 3, 4, 5, + 97, -1, 31, 32, 3, 4, 5, -1, -1, -1, + 3, 4, 5, -1, -1, -1, 3, 4, 5, -1, + 26, 27, -1, 29, 30, 31, -1, 26, 27, -1, + 29, 30, 31, 26, 27, -1, 29, 30, 31, 26, + 27, -1, 29, 30, 31, 3, 4, 5, -1, -1, + -1, 3, 4, 5, -1, -1, -1, 3, 4, 5, + -1, -1, -1, 3, 4, 5, -1, -1, 26, 27, + -1, 29, 30, 31, 26, 27, -1, 29, 30, 31, + 26, 27, -1, 29, 30, 31, 26, 27, -1, 29, + 30, 31, 3, 4, 5, -1, -1, -1, 3, 4, + 5, -1, -1, -1, 3, 4, 5, -1, -1, -1, + 3, 4, 5, -1, -1, 26, 27, -1, 29, 30, + 31, 26, 27, -1, 29, 30, 31, 26, 27, -1, + 29, 30, 31, 26, 27, -1, 29, 30, 31, 3, 4, 5, -1, -1, -1, 3, 4, 5, -1, -1, - -1, 3, 4, 5, -1, 25, 26, -1, 28, 29, - 30, 25, 26, -1, 28, 29, 30, 25, 26, -1, - 28, 29, 30, 25, 26, -1, 28, 29, 30, 3, - 4, 5, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 25, 26, -1, -1, 29, 30 + -1, 3, 4, 5, -1, -1, -1, 3, 4, 5, + -1, -1, 26, 27, -1, 29, 30, 31, 26, 27, + -1, 29, 30, 31, 26, 27, -1, 29, 30, 31, + 26, 27, -1, 29, 30, 31, 3, 4, 5, -1, + -1, -1, 3, 4, 5, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 26, + 27, -1, 29, 30, 31, 26, 27, -1, -1, 30, + 31 }; /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing symbol of state STATE-NUM. */ static const yytype_uint8 yystos[] = { - 0, 33, 0, 1, 3, 5, 6, 7, 8, 9, + 0, 34, 0, 1, 3, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, - 20, 21, 22, 23, 24, 30, 31, 34, 35, 36, + 20, 21, 22, 23, 24, 25, 31, 32, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, - 3, 4, 5, 25, 26, 29, 30, 46, 29, 30, - 30, 30, 30, 46, 46, 46, 46, 3, 4, 5, - 25, 26, 28, 29, 30, 47, 46, 46, 30, 30, - 46, 46, 3, 46, 46, 46, 46, 46, 3, 3, - 3, 3, 3, 3, 26, 46, 3, 3, 3, 3, - 3, 3, 3, 30, 3, 46, 3 + 47, 30, 3, 4, 5, 26, 27, 30, 31, 47, + 30, 31, 31, 31, 31, 47, 47, 47, 47, 3, + 4, 5, 26, 27, 29, 30, 31, 48, 47, 47, + 47, 31, 31, 47, 47, 3, 47, 47, 47, 47, + 47, 3, 3, 3, 3, 3, 3, 3, 27, 47, + 3, 3, 3, 3, 3, 3, 3, 31, 3, 47, + 3 }; /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ static const yytype_uint8 yyr1[] = { - 0, 32, 33, 33, 34, 34, 35, 36, 36, 36, - 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, - 36, 36, 36, 36, 36, 36, 37, 37, 37, 38, - 38, 39, 39, 40, 40, 41, 41, 42, 42, 43, - 43, 44, 44, 45, 45, 46, 46, 47, 47, 47, - 47, 47, 47, 47 + 0, 33, 34, 34, 35, 35, 36, 37, 37, 37, + 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, + 37, 37, 37, 37, 37, 37, 37, 38, 38, 38, + 39, 39, 40, 40, 41, 41, 42, 42, 43, 43, + 44, 44, 45, 45, 46, 46, 47, 47, 48, 48, + 48, 48, 48, 48, 48 }; /* YYR2[YYN] -- Number of symbols on the right hand side of rule YYN. */ static const yytype_uint8 yyr2[] = { 0, 2, 0, 2, 1, 1, 4, 2, 4, 5, - 7, 4, 3, 4, 4, 4, 4, 4, 3, 3, - 3, 3, 4, 3, 1, 1, 1, 1, 1, 1, + 7, 4, 4, 3, 4, 4, 4, 4, 4, 3, + 3, 3, 3, 4, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 0, 2, 1, 1, 1, - 1, 1, 1, 1 + 1, 1, 1, 1, 1, 1, 0, 2, 1, 1, + 1, 1, 1, 1, 1 }; @@ -1439,15 +1449,15 @@ yyreduce: switch (yyn) { case 6: -#line 108 "cmFortranParser.y" /* yacc.c:1646 */ +#line 109 "cmFortranParser.y" /* yacc.c:1646 */ { free((yyvsp[-3].string)); } -#line 1447 "cmFortranParser.cxx" /* yacc.c:1646 */ +#line 1457 "cmFortranParser.cxx" /* yacc.c:1646 */ break; case 7: -#line 114 "cmFortranParser.y" /* yacc.c:1646 */ +#line 115 "cmFortranParser.y" /* yacc.c:1646 */ { if (cmFortranParserIsKeyword((yyvsp[-1].string), "interface")) { @@ -1457,11 +1467,11 @@ yyreduce: } free((yyvsp[-1].string)); } -#line 1461 "cmFortranParser.cxx" /* yacc.c:1646 */ +#line 1471 "cmFortranParser.cxx" /* yacc.c:1646 */ break; case 8: -#line 124 "cmFortranParser.y" /* yacc.c:1646 */ +#line 125 "cmFortranParser.y" /* yacc.c:1646 */ { if (cmFortranParserIsKeyword((yyvsp[-3].string), "use")) { @@ -1491,11 +1501,11 @@ yyreduce: free((yyvsp[-3].string)); free((yyvsp[-2].string)); } -#line 1495 "cmFortranParser.cxx" /* yacc.c:1646 */ +#line 1505 "cmFortranParser.cxx" /* yacc.c:1646 */ break; case 9: -#line 154 "cmFortranParser.y" /* yacc.c:1646 */ +#line 155 "cmFortranParser.y" /* yacc.c:1646 */ { if (cmFortranParserIsKeyword((yyvsp[-4].string), "use")) { @@ -1506,11 +1516,11 @@ yyreduce: free((yyvsp[-4].string)); free((yyvsp[-2].string)); } -#line 1510 "cmFortranParser.cxx" /* yacc.c:1646 */ +#line 1520 "cmFortranParser.cxx" /* yacc.c:1646 */ break; case 10: -#line 165 "cmFortranParser.y" /* yacc.c:1646 */ +#line 166 "cmFortranParser.y" /* yacc.c:1646 */ { if (cmFortranParserIsKeyword((yyvsp[-6].string), "use") && cmFortranParserIsKeyword((yyvsp[-4].string), "non_intrinsic") ) @@ -1523,11 +1533,11 @@ yyreduce: free((yyvsp[-4].string)); free((yyvsp[-2].string)); } -#line 1527 "cmFortranParser.cxx" /* yacc.c:1646 */ +#line 1537 "cmFortranParser.cxx" /* yacc.c:1646 */ break; case 11: -#line 178 "cmFortranParser.y" /* yacc.c:1646 */ +#line 179 "cmFortranParser.y" /* yacc.c:1646 */ { if (cmFortranParserIsKeyword((yyvsp[-3].string), "include")) { @@ -1538,129 +1548,140 @@ yyreduce: free((yyvsp[-3].string)); free((yyvsp[-2].string)); } -#line 1542 "cmFortranParser.cxx" /* yacc.c:1646 */ +#line 1552 "cmFortranParser.cxx" /* yacc.c:1646 */ break; case 12: -#line 189 "cmFortranParser.y" /* yacc.c:1646 */ +#line 190 "cmFortranParser.y" /* yacc.c:1646 */ { cmFortranParser* parser = cmFortran_yyget_extra(yyscanner); - cmFortranParser_RuleInclude(parser, (yyvsp[-2].string)); + cmFortranParser_RuleLineDirective(parser, (yyvsp[-2].string)); free((yyvsp[-2].string)); } -#line 1553 "cmFortranParser.cxx" /* yacc.c:1646 */ +#line 1563 "cmFortranParser.cxx" /* yacc.c:1646 */ break; case 13: -#line 196 "cmFortranParser.y" /* yacc.c:1646 */ +#line 197 "cmFortranParser.y" /* yacc.c:1646 */ { cmFortranParser* parser = cmFortran_yyget_extra(yyscanner); cmFortranParser_RuleInclude(parser, (yyvsp[-2].string)); free((yyvsp[-2].string)); } -#line 1564 "cmFortranParser.cxx" /* yacc.c:1646 */ +#line 1574 "cmFortranParser.cxx" /* yacc.c:1646 */ break; case 14: -#line 203 "cmFortranParser.y" /* yacc.c:1646 */ +#line 204 "cmFortranParser.y" /* yacc.c:1646 */ + { + cmFortranParser* parser = + cmFortran_yyget_extra(yyscanner); + cmFortranParser_RuleInclude(parser, (yyvsp[-2].string)); + free((yyvsp[-2].string)); + } +#line 1585 "cmFortranParser.cxx" /* yacc.c:1646 */ + break; + + case 15: +#line 211 "cmFortranParser.y" /* yacc.c:1646 */ { cmFortranParser* parser = cmFortran_yyget_extra(yyscanner); cmFortranParser_RuleDefine(parser, (yyvsp[-2].string)); free((yyvsp[-2].string)); } -#line 1574 "cmFortranParser.cxx" /* yacc.c:1646 */ +#line 1595 "cmFortranParser.cxx" /* yacc.c:1646 */ break; - case 15: -#line 209 "cmFortranParser.y" /* yacc.c:1646 */ + case 16: +#line 217 "cmFortranParser.y" /* yacc.c:1646 */ { cmFortranParser* parser = cmFortran_yyget_extra(yyscanner); cmFortranParser_RuleUndef(parser, (yyvsp[-2].string)); free((yyvsp[-2].string)); } -#line 1584 "cmFortranParser.cxx" /* yacc.c:1646 */ +#line 1605 "cmFortranParser.cxx" /* yacc.c:1646 */ break; - case 16: -#line 215 "cmFortranParser.y" /* yacc.c:1646 */ + case 17: +#line 223 "cmFortranParser.y" /* yacc.c:1646 */ { cmFortranParser* parser = cmFortran_yyget_extra(yyscanner); cmFortranParser_RuleIfdef(parser, (yyvsp[-2].string)); free((yyvsp[-2].string)); } -#line 1594 "cmFortranParser.cxx" /* yacc.c:1646 */ +#line 1615 "cmFortranParser.cxx" /* yacc.c:1646 */ break; - case 17: -#line 221 "cmFortranParser.y" /* yacc.c:1646 */ + case 18: +#line 229 "cmFortranParser.y" /* yacc.c:1646 */ { cmFortranParser* parser = cmFortran_yyget_extra(yyscanner); cmFortranParser_RuleIfndef(parser, (yyvsp[-2].string)); free((yyvsp[-2].string)); } -#line 1604 "cmFortranParser.cxx" /* yacc.c:1646 */ +#line 1625 "cmFortranParser.cxx" /* yacc.c:1646 */ break; - case 18: -#line 227 "cmFortranParser.y" /* yacc.c:1646 */ + case 19: +#line 235 "cmFortranParser.y" /* yacc.c:1646 */ { cmFortranParser* parser = cmFortran_yyget_extra(yyscanner); cmFortranParser_RuleIf(parser); } -#line 1613 "cmFortranParser.cxx" /* yacc.c:1646 */ +#line 1634 "cmFortranParser.cxx" /* yacc.c:1646 */ break; - case 19: -#line 232 "cmFortranParser.y" /* yacc.c:1646 */ + case 20: +#line 240 "cmFortranParser.y" /* yacc.c:1646 */ { cmFortranParser* parser = cmFortran_yyget_extra(yyscanner); cmFortranParser_RuleElif(parser); } -#line 1622 "cmFortranParser.cxx" /* yacc.c:1646 */ +#line 1643 "cmFortranParser.cxx" /* yacc.c:1646 */ break; - case 20: -#line 237 "cmFortranParser.y" /* yacc.c:1646 */ + case 21: +#line 245 "cmFortranParser.y" /* yacc.c:1646 */ { cmFortranParser* parser = cmFortran_yyget_extra(yyscanner); cmFortranParser_RuleElse(parser); } -#line 1631 "cmFortranParser.cxx" /* yacc.c:1646 */ +#line 1652 "cmFortranParser.cxx" /* yacc.c:1646 */ break; - case 21: -#line 242 "cmFortranParser.y" /* yacc.c:1646 */ + case 22: +#line 250 "cmFortranParser.y" /* yacc.c:1646 */ { cmFortranParser* parser = cmFortran_yyget_extra(yyscanner); cmFortranParser_RuleEndif(parser); } -#line 1640 "cmFortranParser.cxx" /* yacc.c:1646 */ +#line 1661 "cmFortranParser.cxx" /* yacc.c:1646 */ break; - case 22: -#line 247 "cmFortranParser.y" /* yacc.c:1646 */ + case 23: +#line 255 "cmFortranParser.y" /* yacc.c:1646 */ { free((yyvsp[-3].string)); } -#line 1648 "cmFortranParser.cxx" /* yacc.c:1646 */ +#line 1669 "cmFortranParser.cxx" /* yacc.c:1646 */ break; - case 47: -#line 269 "cmFortranParser.y" /* yacc.c:1646 */ + case 48: +#line 277 "cmFortranParser.y" /* yacc.c:1646 */ { free ((yyvsp[0].string)); } -#line 1654 "cmFortranParser.cxx" /* yacc.c:1646 */ +#line 1675 "cmFortranParser.cxx" /* yacc.c:1646 */ break; - case 48: -#line 270 "cmFortranParser.y" /* yacc.c:1646 */ + case 49: +#line 278 "cmFortranParser.y" /* yacc.c:1646 */ { free ((yyvsp[0].string)); } -#line 1660 "cmFortranParser.cxx" /* yacc.c:1646 */ +#line 1681 "cmFortranParser.cxx" /* yacc.c:1646 */ break; -#line 1664 "cmFortranParser.cxx" /* yacc.c:1646 */ +#line 1685 "cmFortranParser.cxx" /* yacc.c:1646 */ default: break; } /* User semantic actions sometimes alter yychar, and that requires @@ -1890,6 +1911,6 @@ yyreturn: #endif return yyresult; } -#line 278 "cmFortranParser.y" /* yacc.c:1906 */ +#line 286 "cmFortranParser.y" /* yacc.c:1906 */ /* End of grammar */ diff --git a/Source/cmFortranParser.h b/Source/cmFortranParser.h index 156c38a..cdaf46b 100644 --- a/Source/cmFortranParser.h +++ b/Source/cmFortranParser.h @@ -55,6 +55,8 @@ void cmFortranParser_Error(cmFortranParser* parser, const char* message); void cmFortranParser_RuleUse(cmFortranParser* parser, const char* name); +void cmFortranParser_RuleLineDirective(cmFortranParser* parser, + const char* filename); void cmFortranParser_RuleInclude(cmFortranParser* parser, const char* name); void cmFortranParser_RuleModule(cmFortranParser* parser, diff --git a/Source/cmFortranParser.y b/Source/cmFortranParser.y index 996bef6..83f441a 100644 --- a/Source/cmFortranParser.y +++ b/Source/cmFortranParser.y @@ -1,7 +1,7 @@ %{ /*============================================================================ CMake - Cross Platform Makefile Generator - Copyright 2000-2009 Kitware, Inc., Insight Software Consortium + Copyright 2000-2015 Kitware, Inc., Insight Software Consortium Distributed under the OSI-approved BSD License (the "License"); see accompanying file Copyright.txt for details. @@ -85,6 +85,7 @@ static bool cmFortranParserIsKeyword(const char* word, /*-------------------------------------------------------------------------*/ /* Tokens */ %token EOSTMT ASSIGNMENT_OP GARBAGE +%token CPP_LINE_DIRECTIVE %token CPP_INCLUDE F90PPR_INCLUDE COCO_INCLUDE %token F90PPR_DEFINE CPP_DEFINE F90PPR_UNDEF CPP_UNDEF %token CPP_IFDEF CPP_IFNDEF CPP_IF CPP_ELSE CPP_ELIF CPP_ENDIF @@ -185,6 +186,13 @@ keyword_stmt: free($1); free($2); } +| CPP_LINE_DIRECTIVE STRING other EOSTMT + { + cmFortranParser* parser = + cmFortran_yyget_extra(yyscanner); + cmFortranParser_RuleLineDirective(parser, $2); + free($2); + } | CPP_INCLUDE_ANGLE other EOSTMT { cmFortranParser* parser = diff --git a/Source/cmFortranParserImpl.cxx b/Source/cmFortranParserImpl.cxx index a09c5459..c175e62 100644 --- a/Source/cmFortranParserImpl.cxx +++ b/Source/cmFortranParserImpl.cxx @@ -210,6 +210,32 @@ void cmFortranParser_RuleUse(cmFortranParser* parser, } //---------------------------------------------------------------------------- +void cmFortranParser_RuleLineDirective(cmFortranParser* parser, + const char* filename) +{ + // This is a #line directive naming a file encountered during preprocessing. + std::string included = filename; + + // Skip #line directives referencing non-files like + // "<built-in>" or "<command-line>". + if (included.empty() || included[0] == '<') + { + return; + } + + // Fix windows file path separators since our lexer does not + // process escape sequences in string literals. + cmSystemTools::ReplaceString(included, "\\\\", "\\"); + cmSystemTools::ConvertToUnixSlashes(included); + + // Save the named file as included in the source. + if (cmSystemTools::FileExists(included)) + { + parser->Info.Includes.insert(included); + } +} + +//---------------------------------------------------------------------------- void cmFortranParser_RuleInclude(cmFortranParser* parser, const char* name) { diff --git a/Source/cmFortranParserTokens.h b/Source/cmFortranParserTokens.h index df1aec3..ac49840 100644 --- a/Source/cmFortranParserTokens.h +++ b/Source/cmFortranParserTokens.h @@ -48,64 +48,66 @@ extern int cmFortran_yydebug; EOSTMT = 258, ASSIGNMENT_OP = 259, GARBAGE = 260, - CPP_INCLUDE = 261, - F90PPR_INCLUDE = 262, - COCO_INCLUDE = 263, - F90PPR_DEFINE = 264, - CPP_DEFINE = 265, - F90PPR_UNDEF = 266, - CPP_UNDEF = 267, - CPP_IFDEF = 268, - CPP_IFNDEF = 269, - CPP_IF = 270, - CPP_ELSE = 271, - CPP_ELIF = 272, - CPP_ENDIF = 273, - F90PPR_IFDEF = 274, - F90PPR_IFNDEF = 275, - F90PPR_IF = 276, - F90PPR_ELSE = 277, - F90PPR_ELIF = 278, - F90PPR_ENDIF = 279, - COMMA = 280, - DCOLON = 281, - CPP_TOENDL = 282, - UNTERMINATED_STRING = 283, - STRING = 284, - WORD = 285, - CPP_INCLUDE_ANGLE = 286 + CPP_LINE_DIRECTIVE = 261, + CPP_INCLUDE = 262, + F90PPR_INCLUDE = 263, + COCO_INCLUDE = 264, + F90PPR_DEFINE = 265, + CPP_DEFINE = 266, + F90PPR_UNDEF = 267, + CPP_UNDEF = 268, + CPP_IFDEF = 269, + CPP_IFNDEF = 270, + CPP_IF = 271, + CPP_ELSE = 272, + CPP_ELIF = 273, + CPP_ENDIF = 274, + F90PPR_IFDEF = 275, + F90PPR_IFNDEF = 276, + F90PPR_IF = 277, + F90PPR_ELSE = 278, + F90PPR_ELIF = 279, + F90PPR_ENDIF = 280, + COMMA = 281, + DCOLON = 282, + CPP_TOENDL = 283, + UNTERMINATED_STRING = 284, + STRING = 285, + WORD = 286, + CPP_INCLUDE_ANGLE = 287 }; #endif /* Tokens. */ #define EOSTMT 258 #define ASSIGNMENT_OP 259 #define GARBAGE 260 -#define CPP_INCLUDE 261 -#define F90PPR_INCLUDE 262 -#define COCO_INCLUDE 263 -#define F90PPR_DEFINE 264 -#define CPP_DEFINE 265 -#define F90PPR_UNDEF 266 -#define CPP_UNDEF 267 -#define CPP_IFDEF 268 -#define CPP_IFNDEF 269 -#define CPP_IF 270 -#define CPP_ELSE 271 -#define CPP_ELIF 272 -#define CPP_ENDIF 273 -#define F90PPR_IFDEF 274 -#define F90PPR_IFNDEF 275 -#define F90PPR_IF 276 -#define F90PPR_ELSE 277 -#define F90PPR_ELIF 278 -#define F90PPR_ENDIF 279 -#define COMMA 280 -#define DCOLON 281 -#define CPP_TOENDL 282 -#define UNTERMINATED_STRING 283 -#define STRING 284 -#define WORD 285 -#define CPP_INCLUDE_ANGLE 286 +#define CPP_LINE_DIRECTIVE 261 +#define CPP_INCLUDE 262 +#define F90PPR_INCLUDE 263 +#define COCO_INCLUDE 264 +#define F90PPR_DEFINE 265 +#define CPP_DEFINE 266 +#define F90PPR_UNDEF 267 +#define CPP_UNDEF 268 +#define CPP_IFDEF 269 +#define CPP_IFNDEF 270 +#define CPP_IF 271 +#define CPP_ELSE 272 +#define CPP_ELIF 273 +#define CPP_ENDIF 274 +#define F90PPR_IFDEF 275 +#define F90PPR_IFNDEF 276 +#define F90PPR_IF 277 +#define F90PPR_ELSE 278 +#define F90PPR_ELIF 279 +#define F90PPR_ENDIF 280 +#define COMMA 281 +#define DCOLON 282 +#define CPP_TOENDL 283 +#define UNTERMINATED_STRING 284 +#define STRING 285 +#define WORD 286 +#define CPP_INCLUDE_ANGLE 287 /* Value type. */ #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED @@ -116,7 +118,7 @@ union YYSTYPE char* string; -#line 120 "cmFortranParserTokens.h" /* yacc.c:1909 */ +#line 122 "cmFortranParserTokens.h" /* yacc.c:1909 */ }; # define YYSTYPE_IS_TRIVIAL 1 # define YYSTYPE_IS_DECLARED 1 diff --git a/Source/cmFunctionBlocker.h b/Source/cmFunctionBlocker.h index 68bf762..a3b8078 100644 --- a/Source/cmFunctionBlocker.h +++ b/Source/cmFunctionBlocker.h @@ -39,7 +39,7 @@ public: /** Set/Get the context in which this blocker is created. */ void SetStartingContext(cmListFileContext const& lfc) { this->StartingContext = lfc; } - cmListFileContext const& GetStartingContext() + cmListFileContext const& GetStartingContext() const { return this->StartingContext; } private: cmListFileContext StartingContext; diff --git a/Source/cmGeneratorExpression.cxx b/Source/cmGeneratorExpression.cxx index 80a4f81..6796a01 100644 --- a/Source/cmGeneratorExpression.cxx +++ b/Source/cmGeneratorExpression.cxx @@ -11,10 +11,9 @@ ============================================================================*/ #include "cmGeneratorExpression.h" -#include "cmMakefile.h" -#include "cmTarget.h" #include "assert.h" #include "cmAlgorithms.h" +#include "cmSystemTools.h" #include "cmGeneratorExpressionEvaluator.h" #include "cmGeneratorExpressionLexer.h" @@ -48,13 +47,13 @@ cmGeneratorExpression::~cmGeneratorExpression() } //---------------------------------------------------------------------------- -const char *cmCompiledGeneratorExpression::Evaluate( - cmMakefile* mf, const std::string& config, bool quiet, - cmTarget const* headTarget, +const char *cmCompiledGeneratorExpression::Evaluate(cmLocalGenerator* lg, + const std::string& config, bool quiet, + const cmGeneratorTarget* headTarget, cmGeneratorExpressionDAGChecker *dagChecker, std::string const& language) const { - return this->Evaluate(mf, + return this->Evaluate(lg, config, quiet, headTarget, @@ -65,13 +64,13 @@ const char *cmCompiledGeneratorExpression::Evaluate( //---------------------------------------------------------------------------- const char *cmCompiledGeneratorExpression::Evaluate( - cmMakefile* mf, const std::string& config, bool quiet, - cmTarget const* headTarget, - cmTarget const* currentTarget, + cmLocalGenerator* lg, const std::string& config, bool quiet, + const cmGeneratorTarget* headTarget, + const cmGeneratorTarget* currentTarget, cmGeneratorExpressionDAGChecker *dagChecker, std::string const& language) const { - cmGeneratorExpressionContext context(mf, config, quiet, headTarget, + cmGeneratorExpressionContext context(lg, config, quiet, headTarget, currentTarget ? currentTarget : headTarget, this->EvaluateForBuildsystem, this->Backtrace, language); @@ -463,10 +462,11 @@ bool cmGeneratorExpression::IsValidTargetName(const std::string &input) //---------------------------------------------------------------------------- void -cmCompiledGeneratorExpression::GetMaxLanguageStandard(cmTarget const* tgt, +cmCompiledGeneratorExpression::GetMaxLanguageStandard( + const cmGeneratorTarget* tgt, std::map<std::string, std::string>& mapping) { - typedef std::map<cmTarget const*, + typedef std::map<cmGeneratorTarget const*, std::map<std::string, std::string> > MapType; MapType::const_iterator it = this->MaxLanguageStandard.find(tgt); if (it != this->MaxLanguageStandard.end()) diff --git a/Source/cmGeneratorExpression.h b/Source/cmGeneratorExpression.h index cd19bc0..efd381b 100644 --- a/Source/cmGeneratorExpression.h +++ b/Source/cmGeneratorExpression.h @@ -19,8 +19,8 @@ #include <cmsys/RegularExpression.hxx> #include <cmsys/auto_ptr.hxx> -class cmTarget; -class cmMakefile; +class cmGeneratorTarget; +class cmLocalGenerator; class cmListFileBacktrace; struct cmGeneratorExpressionEvaluator; @@ -78,26 +78,26 @@ private: class cmCompiledGeneratorExpression { public: - const char* Evaluate(cmMakefile* mf, const std::string& config, + const char* Evaluate(cmLocalGenerator* lg, const std::string& config, bool quiet = false, - cmTarget const* headTarget = 0, - cmTarget const* currentTarget = 0, + cmGeneratorTarget const* headTarget = 0, + cmGeneratorTarget const* currentTarget = 0, cmGeneratorExpressionDAGChecker *dagChecker = 0, std::string const& language = std::string()) const; - const char* Evaluate(cmMakefile* mf, const std::string& config, + const char* Evaluate(cmLocalGenerator* lg, const std::string& config, bool quiet, - cmTarget const* headTarget, + cmGeneratorTarget const* headTarget, cmGeneratorExpressionDAGChecker *dagChecker, std::string const& language = std::string()) const; /** Get set of targets found during evaluations. */ - std::set<cmTarget*> const& GetTargets() const + std::set<cmGeneratorTarget*> const& GetTargets() const { return this->DependTargets; } std::set<std::string> const& GetSeenTargetProperties() const { return this->SeenTargetProperties; } - std::set<cmTarget const*> const& GetAllTargetsSeen() const + std::set<cmGeneratorTarget const*> const& GetAllTargetsSeen() const { return this->AllTargetsSeen; } ~cmCompiledGeneratorExpression(); @@ -119,7 +119,7 @@ public: { return this->HadHeadSensitiveCondition; } - std::set<cmTarget const*> GetSourceSensitiveTargets() const + std::set<cmGeneratorTarget const*> GetSourceSensitiveTargets() const { return this->SourceSensitiveTargets; } @@ -129,7 +129,7 @@ public: this->EvaluateForBuildsystem = eval; } - void GetMaxLanguageStandard(cmTarget const* tgt, + void GetMaxLanguageStandard(cmGeneratorTarget const* tgt, std::map<std::string, std::string>& mapping); private: @@ -149,15 +149,15 @@ private: const std::string Input; bool NeedsEvaluation; - mutable std::set<cmTarget*> DependTargets; - mutable std::set<cmTarget const*> AllTargetsSeen; + mutable std::set<cmGeneratorTarget*> DependTargets; + mutable std::set<cmGeneratorTarget const*> AllTargetsSeen; mutable std::set<std::string> SeenTargetProperties; - mutable std::map<cmTarget const*, std::map<std::string, std::string> > - MaxLanguageStandard; + mutable std::map<cmGeneratorTarget const*, + std::map<std::string, std::string> > MaxLanguageStandard; mutable std::string Output; mutable bool HadContextSensitiveCondition; mutable bool HadHeadSensitiveCondition; - mutable std::set<cmTarget const*> SourceSensitiveTargets; + mutable std::set<cmGeneratorTarget const*> SourceSensitiveTargets; bool EvaluateForBuildsystem; }; diff --git a/Source/cmGeneratorExpressionContext.cxx b/Source/cmGeneratorExpressionContext.cxx index 947015e..5c9462f 100644 --- a/Source/cmGeneratorExpressionContext.cxx +++ b/Source/cmGeneratorExpressionContext.cxx @@ -11,16 +11,17 @@ ============================================================================*/ #include "cmGeneratorExpressionContext.h" +#include "cmGeneratorTarget.h" cmGeneratorExpressionContext::cmGeneratorExpressionContext( - cmMakefile* mf, std::string const& config, - bool quiet, cmTarget const* headTarget, - cmTarget const* currentTarget, + cmLocalGenerator* lg, std::string const& config, + bool quiet, cmGeneratorTarget const* headTarget, + const cmGeneratorTarget* currentTarget, bool evaluateForBuildsystem, cmListFileBacktrace const& backtrace, std::string const& language) : Backtrace(backtrace), - Makefile(mf), + LG(lg), Config(config), Language(language), HeadTarget(headTarget), diff --git a/Source/cmGeneratorExpressionContext.h b/Source/cmGeneratorExpressionContext.h index ed83509..e802138 100644 --- a/Source/cmGeneratorExpressionContext.h +++ b/Source/cmGeneratorExpressionContext.h @@ -18,32 +18,35 @@ #include <map> #include <string> -class cmTarget; +class cmGeneratorTarget; +class cmLocalGenerator; //---------------------------------------------------------------------------- struct cmGeneratorExpressionContext { - cmGeneratorExpressionContext(cmMakefile* mf, std::string const& config, - bool quiet, cmTarget const* headTarget, - cmTarget const* currentTarget, + cmGeneratorExpressionContext(cmLocalGenerator* lg, std::string const& config, + bool quiet, const cmGeneratorTarget* headTarget, + cmGeneratorTarget const* currentTarget, bool evaluateForBuildsystem, cmListFileBacktrace const& backtrace, std::string const& language); cmListFileBacktrace Backtrace; - std::set<cmTarget*> DependTargets; - std::set<cmTarget const*> AllTargets; + std::set<cmGeneratorTarget*> DependTargets; + std::set<cmGeneratorTarget const*> AllTargets; std::set<std::string> SeenTargetProperties; - std::set<cmTarget const*> SourceSensitiveTargets; - std::map<cmTarget const*, std::map<std::string, std::string> > + std::set<cmGeneratorTarget const*> SourceSensitiveTargets; + std::map<cmGeneratorTarget const*, std::map<std::string, std::string> > MaxLanguageStandard; - cmMakefile *Makefile; + cmLocalGenerator *LG; std::string Config; std::string Language; - cmTarget const* HeadTarget; // The target whose property is being evaluated. - cmTarget const* CurrentTarget; // The dependent of HeadTarget which appears - // directly or indirectly in the property. + // The target whose property is being evaluated. + cmGeneratorTarget const* HeadTarget; + // The dependent of HeadTarget which appears + // directly or indirectly in the property. + cmGeneratorTarget const* CurrentTarget; bool Quiet; bool HadError; bool HadContextSensitiveCondition; diff --git a/Source/cmGeneratorExpressionDAGChecker.cxx b/Source/cmGeneratorExpressionDAGChecker.cxx index 851aacd..c3b0272 100644 --- a/Source/cmGeneratorExpressionDAGChecker.cxx +++ b/Source/cmGeneratorExpressionDAGChecker.cxx @@ -12,7 +12,7 @@ #include "cmGeneratorExpressionDAGChecker.h" -#include "cmMakefile.h" +#include "cmLocalGenerator.h" #include "cmAlgorithms.h" //---------------------------------------------------------------------------- @@ -110,7 +110,7 @@ void cmGeneratorExpressionDAGChecker::ReportError( << " " << expr << "\n" << "Self reference on target \"" << context->HeadTarget->GetName() << "\".\n"; - context->Makefile->GetCMakeInstance() + context->LG->GetCMakeInstance() ->IssueMessage(cmake::FATAL_ERROR, e.str(), parent->Backtrace); return; @@ -121,7 +121,7 @@ void cmGeneratorExpressionDAGChecker::ReportError( e << "Error evaluating generator expression:\n" << " " << expr << "\n" << "Dependency loop found."; - context->Makefile->GetCMakeInstance() + context->LG->GetCMakeInstance() ->IssueMessage(cmake::FATAL_ERROR, e.str(), context->Backtrace); } @@ -134,7 +134,7 @@ void cmGeneratorExpressionDAGChecker::ReportError( << " " << (parent->Content ? parent->Content->GetOriginalExpression() : expr) << "\n"; - context->Makefile->GetCMakeInstance() + context->LG->GetCMakeInstance() ->IssueMessage(cmake::FATAL_ERROR, e.str(), parent->Backtrace); parent = parent->Parent; diff --git a/Source/cmGeneratorExpressionEvaluationFile.cxx b/Source/cmGeneratorExpressionEvaluationFile.cxx index e4d9f10..4ac2a0d 100644 --- a/Source/cmGeneratorExpressionEvaluationFile.cxx +++ b/Source/cmGeneratorExpressionEvaluationFile.cxx @@ -44,7 +44,7 @@ void cmGeneratorExpressionEvaluationFile::Generate(cmLocalGenerator* lg, std::string rawCondition = this->Condition->GetInput(); if (!rawCondition.empty()) { - std::string condResult = this->Condition->Evaluate(lg->GetMakefile(), + std::string condResult = this->Condition->Evaluate(lg, config, false, 0, 0, 0, lang); if (condResult == "0") @@ -62,10 +62,10 @@ void cmGeneratorExpressionEvaluationFile::Generate(cmLocalGenerator* lg, } const std::string outputFileName - = this->OutputFileExpr->Evaluate(lg->GetMakefile(), config, + = this->OutputFileExpr->Evaluate(lg, config, false, 0, 0, 0, lang); const std::string outputContent - = inputExpression->Evaluate(lg->GetMakefile(), + = inputExpression->Evaluate(lg, config, false, 0, 0, 0, lang); @@ -110,7 +110,7 @@ void cmGeneratorExpressionEvaluationFile::CreateOutputFile( for(std::vector<std::string>::const_iterator le = enabledLanguages.begin(); le != enabledLanguages.end(); ++le) { - std::string name = this->OutputFileExpr->Evaluate(lg->GetMakefile(), + std::string name = this->OutputFileExpr->Evaluate(lg, config, false, 0, 0, 0, *le); cmSourceFile* sf = lg->GetMakefile()->GetOrCreateSource(name); @@ -139,7 +139,7 @@ void cmGeneratorExpressionEvaluationFile::Generate(cmLocalGenerator *lg) { std::ostringstream e; e << "Evaluation file \"" << this->Input << "\" cannot be read."; - lg->GetMakefile()->IssueMessage(cmake::FATAL_ERROR, e.str()); + lg->IssueMessage(cmake::FATAL_ERROR, e.str()); return; } diff --git a/Source/cmGeneratorExpressionEvaluator.h b/Source/cmGeneratorExpressionEvaluator.h index 7c1bd8c..407f83f 100644 --- a/Source/cmGeneratorExpressionEvaluator.h +++ b/Source/cmGeneratorExpressionEvaluator.h @@ -12,13 +12,11 @@ #ifndef cmGeneratorExpressionEvaluator_h #define cmGeneratorExpressionEvaluator_h -#include <vector> -#include <string> - #include "cmListFileCache.h" #include "cmGeneratorExpressionContext.h" -class cmTarget; +#include <vector> +#include <string> struct cmGeneratorExpressionDAGChecker; struct cmGeneratorExpressionNode; diff --git a/Source/cmGeneratorExpressionNode.cxx b/Source/cmGeneratorExpressionNode.cxx index 1c350ab..32b2f82 100644 --- a/Source/cmGeneratorExpressionNode.cxx +++ b/Source/cmGeneratorExpressionNode.cxx @@ -14,18 +14,20 @@ #include "cmGlobalGenerator.h" #include "cmAlgorithms.h" #include "cmOutputConverter.h" +#include "cmMakefile.h" //---------------------------------------------------------------------------- std::string cmGeneratorExpressionNode::EvaluateDependentExpression( - std::string const& prop, cmMakefile *makefile, + std::string const& prop, cmLocalGenerator *lg, cmGeneratorExpressionContext *context, - cmTarget const* headTarget, cmTarget const* currentTarget, + cmGeneratorTarget const* headTarget, + cmGeneratorTarget const* currentTarget, cmGeneratorExpressionDAGChecker *dagChecker) { cmGeneratorExpression ge(context->Backtrace); cmsys::auto_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(prop); cge->SetEvaluateForBuildsystem(context->EvaluateForBuildsystem); - std::string result = cge->Evaluate(makefile, + std::string result = cge->Evaluate(lg, context->Config, context->Quiet, headTarget, @@ -367,7 +369,8 @@ struct CompilerIdNode : public cmGeneratorExpressionNode const std::string &lang) const { const char *compilerId = - context->Makefile->GetSafeDefinition("CMAKE_" + lang + "_COMPILER_ID"); + context->LG->GetMakefile() + ->GetSafeDefinition("CMAKE_" + lang + "_COMPILER_ID"); if (parameters.empty()) { return compilerId ? compilerId : ""; @@ -391,13 +394,13 @@ struct CompilerIdNode : public cmGeneratorExpressionNode if (cmsysString_strcasecmp(parameters.begin()->c_str(), compilerId) == 0) { - switch(context->Makefile->GetPolicyStatus(cmPolicies::CMP0044)) + switch(context->LG->GetPolicyStatus(cmPolicies::CMP0044)) { case cmPolicies::WARN: { std::ostringstream e; e << cmPolicies::GetPolicyWarning(cmPolicies::CMP0044); - context->Makefile->GetCMakeInstance() + context->LG->GetCMakeInstance() ->IssueMessage(cmake::AUTHOR_WARNING, e.str(), context->Backtrace); } @@ -470,8 +473,9 @@ struct CompilerVersionNode : public cmGeneratorExpressionNode cmGeneratorExpressionDAGChecker *, const std::string &lang) const { - const char *compilerVersion = context->Makefile->GetSafeDefinition( - "CMAKE_" + lang + "_COMPILER_VERSION"); + const char *compilerVersion = + context->LG->GetMakefile()->GetSafeDefinition( + "CMAKE_" + lang + "_COMPILER_VERSION"); if (parameters.empty()) { return compilerVersion ? compilerVersion : ""; @@ -553,7 +557,7 @@ struct PlatformIdNode : public cmGeneratorExpressionNode cmGeneratorExpressionDAGChecker *) const { const char *platformId = - context->Makefile->GetSafeDefinition("CMAKE_SYSTEM_NAME"); + context->LG->GetMakefile()->GetSafeDefinition("CMAKE_SYSTEM_NAME"); if (parameters.empty()) { return platformId ? platformId : ""; @@ -702,7 +706,7 @@ static const struct ConfigurationTestNode : public cmGeneratorExpressionNode const char* loc = 0; const char* imp = 0; std::string suffix; - if (context->CurrentTarget->GetMappedConfig(context->Config, + if (context->CurrentTarget->Target->GetMappedConfig(context->Config, &loc, &imp, suffix)) @@ -768,7 +772,7 @@ static const struct CompileLanguageNode : public cmGeneratorExpressionNode } std::vector<std::string> enabledLanguages; - cmGlobalGenerator* gg = context->Makefile->GetGlobalGenerator(); + cmGlobalGenerator* gg = context->LG->GetGlobalGenerator(); gg->GetEnabledLanguages(enabledLanguages); if (!parameters.empty() && std::find(enabledLanguages.begin(), enabledLanguages.end(), @@ -831,8 +835,8 @@ template <typename T> std::string getLinkedTargetsContent( std::vector<T> const &libraries, - cmTarget const* target, - cmTarget const* headTarget, + cmGeneratorTarget const* target, + cmGeneratorTarget const* headTarget, cmGeneratorExpressionContext *context, cmGeneratorExpressionDAGChecker *dagChecker, const std::string &interfacePropertyName) @@ -858,8 +862,10 @@ getLinkedTargetsContent( { linkedTargetsContent = cmGeneratorExpressionNode::EvaluateDependentExpression(depString, - target->GetMakefile(), context, - headTarget, target, dagChecker); + target->GetLocalGenerator(), + context, + headTarget, + target, dagChecker); } linkedTargetsContent = cmGeneratorExpression::StripEmptyListElements(linkedTargetsContent); @@ -888,7 +894,7 @@ static const struct TargetPropertyNode : public cmGeneratorExpressionNode } static cmsys::RegularExpression propertyNameValidator("^[A-Za-z0-9_]+$"); - cmTarget const* target = context->HeadTarget; + cmGeneratorTarget const* target = context->HeadTarget; std::string propertyName = *parameters.begin(); if (parameters.size() == 1) @@ -938,16 +944,17 @@ static const struct TargetPropertyNode : public cmGeneratorExpressionNode } if(propertyName == "ALIASED_TARGET") { - if(context->Makefile->IsAlias(targetName)) + if(context->LG->GetMakefile()->IsAlias(targetName)) { - if(cmTarget* tgt = context->Makefile->FindTargetToUse(targetName)) + if(cmGeneratorTarget* tgt = + context->LG->FindGeneratorTargetToUse(targetName)) { return tgt->GetName(); } } return ""; } - target = context->Makefile->FindTargetToUse(targetName); + target = context->LG->FindGeneratorTargetToUse(targetName); if (!target) { @@ -991,9 +998,6 @@ static const struct TargetPropertyNode : public cmGeneratorExpressionNode assert(target); - cmGeneratorTarget* gtgt = - context->Makefile->GetGlobalGenerator()->GetGeneratorTarget(target); - if (propertyName == "LINKER_LANGUAGE") { if (target->LinkLanguagePropagatesToDependents() && @@ -1005,7 +1009,7 @@ static const struct TargetPropertyNode : public cmGeneratorExpressionNode "link libraries for a static library"); return std::string(); } - return gtgt->GetLinkerLanguage(context->Config); + return target->GetLinkerLanguage(context->Config); } cmGeneratorExpressionDAGChecker dagChecker(context->Backtrace, @@ -1097,20 +1101,21 @@ static const struct TargetPropertyNode : public cmGeneratorExpressionNode "COMPILE_DEFINITIONS_")) { cmPolicies::PolicyStatus polSt = - context->Makefile->GetPolicyStatus(cmPolicies::CMP0043); + context->LG->GetPolicyStatus(cmPolicies::CMP0043); if (polSt == cmPolicies::WARN || polSt == cmPolicies::OLD) { interfacePropertyName = "INTERFACE_COMPILE_DEFINITIONS"; } } #undef POPULATE_INTERFACE_PROPERTY_NAME - cmTarget const* headTarget = context->HeadTarget && isInterfaceProperty + cmGeneratorTarget const* headTarget = + context->HeadTarget && isInterfaceProperty ? context->HeadTarget : target; if(isInterfaceProperty) { if(cmLinkInterfaceLibraries const* iface = - gtgt->GetLinkInterfaceLibraries(context->Config, headTarget, true)) + target->GetLinkInterfaceLibraries(context->Config, headTarget, true)) { linkedTargetsContent = getLinkedTargetsContent(iface->Libraries, target, @@ -1135,44 +1140,44 @@ static const struct TargetPropertyNode : public cmGeneratorExpressionNode if (!prop) { if (target->IsImported() - || target->GetType() == cmTarget::INTERFACE_LIBRARY) + || target->GetType() == cmState::INTERFACE_LIBRARY) { return linkedTargetsContent; } - if (gtgt->IsLinkInterfaceDependentBoolProperty(propertyName, + if (target->IsLinkInterfaceDependentBoolProperty(propertyName, context->Config)) { context->HadContextSensitiveCondition = true; - return gtgt->GetLinkInterfaceDependentBoolProperty( + return target->GetLinkInterfaceDependentBoolProperty( propertyName, context->Config) ? "1" : "0"; } - if (gtgt->IsLinkInterfaceDependentStringProperty(propertyName, + if (target->IsLinkInterfaceDependentStringProperty(propertyName, context->Config)) { context->HadContextSensitiveCondition = true; const char *propContent = - gtgt->GetLinkInterfaceDependentStringProperty( + target->GetLinkInterfaceDependentStringProperty( propertyName, context->Config); return propContent ? propContent : ""; } - if (gtgt->IsLinkInterfaceDependentNumberMinProperty(propertyName, + if (target->IsLinkInterfaceDependentNumberMinProperty(propertyName, context->Config)) { context->HadContextSensitiveCondition = true; const char *propContent = - gtgt->GetLinkInterfaceDependentNumberMinProperty( + target->GetLinkInterfaceDependentNumberMinProperty( propertyName, context->Config); return propContent ? propContent : ""; } - if (gtgt->IsLinkInterfaceDependentNumberMaxProperty(propertyName, + if (target->IsLinkInterfaceDependentNumberMaxProperty(propertyName, context->Config)) { context->HadContextSensitiveCondition = true; const char *propContent = - gtgt->GetLinkInterfaceDependentNumberMaxProperty( + target->GetLinkInterfaceDependentNumberMaxProperty( propertyName, context->Config); return propContent ? propContent : ""; @@ -1184,22 +1189,22 @@ static const struct TargetPropertyNode : public cmGeneratorExpressionNode if (!target->IsImported() && dagCheckerParent && !dagCheckerParent->EvaluatingLinkLibraries()) { - if (gtgt->IsLinkInterfaceDependentNumberMinProperty(propertyName, + if (target->IsLinkInterfaceDependentNumberMinProperty(propertyName, context->Config)) { context->HadContextSensitiveCondition = true; const char *propContent = - gtgt->GetLinkInterfaceDependentNumberMinProperty( + target->GetLinkInterfaceDependentNumberMinProperty( propertyName, context->Config); return propContent ? propContent : ""; } - if (gtgt->IsLinkInterfaceDependentNumberMaxProperty(propertyName, + if (target->IsLinkInterfaceDependentNumberMaxProperty(propertyName, context->Config)) { context->HadContextSensitiveCondition = true; const char *propContent = - gtgt->GetLinkInterfaceDependentNumberMaxProperty( + target->GetLinkInterfaceDependentNumberMaxProperty( propertyName, context->Config); return propContent ? propContent : ""; @@ -1208,7 +1213,7 @@ static const struct TargetPropertyNode : public cmGeneratorExpressionNode if(!interfacePropertyName.empty()) { std::string result = this->EvaluateDependentExpression(prop, - context->Makefile, context, + context->LG, context, headTarget, target, &dagChecker); if (!linkedTargetsContent.empty()) { @@ -1264,7 +1269,7 @@ static const struct TargetObjectsNode : public cmGeneratorExpressionNode std::string tgtName = parameters.front(); cmGeneratorTarget* gt = - context->Makefile->FindGeneratorTargetToUse(tgtName); + context->LG->FindGeneratorTargetToUse(tgtName); if (!gt) { std::ostringstream e; @@ -1273,7 +1278,7 @@ static const struct TargetObjectsNode : public cmGeneratorExpressionNode reportError(context, content->GetOriginalExpression(), e.str()); return std::string(); } - if (gt->GetType() != cmTarget::OBJECT_LIBRARY) + if (gt->GetType() != cmState::OBJECT_LIBRARY) { std::ostringstream e; e << "Objects of target \"" << tgtName @@ -1307,7 +1312,8 @@ static const struct TargetObjectsNode : public cmGeneratorExpressionNode assert(!map_it->second.empty()); result += sep; std::string objFile = obj_dir + map_it->second; - cmSourceFile* sf = context->Makefile->GetOrCreateSource(objFile, true); + cmSourceFile* sf = + context->LG->GetMakefile()->GetOrCreateSource(objFile, true); sf->SetObjectLibrary(tgtName); sf->SetProperty("EXTERNAL_OBJECT", "1"); result += objFile; @@ -1329,7 +1335,7 @@ static const struct CompileFeaturesNode : public cmGeneratorExpressionNode const GeneratorExpressionContent *content, cmGeneratorExpressionDAGChecker *dagChecker) const { - cmTarget const* target = context->HeadTarget; + cmGeneratorTarget const* target = context->HeadTarget; if (!target) { reportError(context, content->GetOriginalExpression(), @@ -1349,7 +1355,8 @@ static const struct CompileFeaturesNode : public cmGeneratorExpressionNode { std::string error; std::string lang; - if (!context->Makefile->CompileFeatureKnown(context->HeadTarget, + if (!context->LG->GetMakefile()->CompileFeatureKnown( + context->HeadTarget->Target, *it, lang, &error)) { reportError(context, content->GetOriginalExpression(), error); @@ -1360,7 +1367,8 @@ static const struct CompileFeaturesNode : public cmGeneratorExpressionNode if (availableFeatures.find(lang) == availableFeatures.end()) { const char* featuresKnown - = context->Makefile->CompileFeaturesAvailable(lang, &error); + = context->LG->GetMakefile()->CompileFeaturesAvailable(lang, + &error); if (!featuresKnown) { reportError(context, content->GetOriginalExpression(), error); @@ -1378,7 +1386,7 @@ static const struct CompileFeaturesNode : public cmGeneratorExpressionNode { std::vector<std::string> const& langAvailable = availableFeatures[lit->first]; - const char* standardDefault = context->Makefile + const char* standardDefault = context->LG->GetMakefile() ->GetDefinition("CMAKE_" + lit->first + "_STANDARD_DEFAULT"); for (std::vector<std::string>::const_iterator it = lit->second.begin(); it != lit->second.end(); ++it) @@ -1394,7 +1402,7 @@ static const struct CompileFeaturesNode : public cmGeneratorExpressionNode // All features known for the language are always available. continue; } - if (!context->Makefile->HaveStandardAvailable(target, + if (!context->LG->GetMakefile()->HaveStandardAvailable(target->Target, lit->first, *it)) { if (evalLL) @@ -1429,7 +1437,7 @@ static const char* targetPolicyWhitelist[] = { #undef TARGET_POLICY_STRING }; -cmPolicies::PolicyStatus statusForTarget(cmTarget const* tgt, +cmPolicies::PolicyStatus statusForTarget(cmGeneratorTarget const* tgt, const char *policy) { #define RETURN_POLICY(POLICY) \ @@ -1490,11 +1498,11 @@ static const struct TargetPolicyNode : public cmGeneratorExpressionNode const char *policy = targetPolicyWhitelist[i]; if (parameters.front() == policy) { - cmMakefile *mf = context->HeadTarget->GetMakefile(); + cmLocalGenerator* lg = context->HeadTarget->GetLocalGenerator(); switch(statusForTarget(context->HeadTarget, policy)) { case cmPolicies::WARN: - mf->IssueMessage(cmake::AUTHOR_WARNING, + lg->IssueMessage(cmake::AUTHOR_WARNING, cmPolicies::GetPolicyWarning(policyForString(policy))); case cmPolicies::REQUIRED_IF_USED: case cmPolicies::REQUIRED_ALWAYS: @@ -1572,21 +1580,21 @@ struct TargetFilesystemArtifactResultCreator<ArtifactSonameTag> const GeneratorExpressionContent *content) { // The target soname file (.so.1). - if(target->Target->IsDLLPlatform()) + if(target->IsDLLPlatform()) { ::reportError(context, content->GetOriginalExpression(), "TARGET_SONAME_FILE is not allowed " "for DLL target platforms."); return std::string(); } - if(target->GetType() != cmTarget::SHARED_LIBRARY) + if(target->GetType() != cmState::SHARED_LIBRARY) { ::reportError(context, content->GetOriginalExpression(), "TARGET_SONAME_FILE is allowed only for " "SHARED libraries."); return std::string(); } - std::string result = target->Target->GetDirectory(context->Config); + std::string result = target->GetDirectory(context->Config); result += "/"; result += target->GetSOName(context->Config); return result; @@ -1612,18 +1620,18 @@ struct TargetFilesystemArtifactResultCreator<ArtifactPdbTag> std::string pdbSupportVar = "CMAKE_" + language + "_LINKER_SUPPORTS_PDB"; - if(!context->Makefile->IsOn(pdbSupportVar)) + if(!context->LG->GetMakefile()->IsOn(pdbSupportVar)) { ::reportError(context, content->GetOriginalExpression(), "TARGET_PDB_FILE is not supported by the target linker."); return std::string(); } - cmTarget::TargetType targetType = target->Target->GetType(); + cmState::TargetType targetType = target->GetType(); - if(targetType != cmTarget::SHARED_LIBRARY && - targetType != cmTarget::MODULE_LIBRARY && - targetType != cmTarget::EXECUTABLE) + if(targetType != cmState::SHARED_LIBRARY && + targetType != cmState::MODULE_LIBRARY && + targetType != cmState::EXECUTABLE) { ::reportError(context, content->GetOriginalExpression(), "TARGET_PDB_FILE is allowed only for " @@ -1631,7 +1639,7 @@ struct TargetFilesystemArtifactResultCreator<ArtifactPdbTag> return std::string(); } - std::string result = target->Target->GetPDBDirectory(context->Config); + std::string result = target->GetPDBDirectory(context->Config); result += "/"; result += target->GetPDBName(context->Config); return result; @@ -1647,7 +1655,7 @@ struct TargetFilesystemArtifactResultCreator<ArtifactLinkerTag> const GeneratorExpressionContent *content) { // The file used to link to the target (.so, .lib, .a). - if(!target->Target->IsLinkable()) + if(!target->IsLinkable()) { ::reportError(context, content->GetOriginalExpression(), "TARGET_LINKER_FILE is allowed only for libraries and " @@ -1655,7 +1663,7 @@ struct TargetFilesystemArtifactResultCreator<ArtifactLinkerTag> return std::string(); } return target->GetFullPath(context->Config, - target->Target->HasImportLibrary()); + target->HasImportLibrary()); } }; @@ -1726,15 +1734,15 @@ struct TargetFilesystemArtifact : public cmGeneratorExpressionNode return std::string(); } cmGeneratorTarget* target = - context->Makefile->FindGeneratorTargetToUse(name); + context->LG->FindGeneratorTargetToUse(name); if(!target) { ::reportError(context, content->GetOriginalExpression(), "No target \"" + name + "\""); return std::string(); } - if(target->GetType() >= cmTarget::OBJECT_LIBRARY && - target->GetType() != cmTarget::UNKNOWN_LIBRARY) + if(target->GetType() >= cmState::OBJECT_LIBRARY && + target->GetType() != cmState::UNKNOWN_LIBRARY) { ::reportError(context, content->GetOriginalExpression(), "Target \"" + name + "\" is not an executable or library."); @@ -1749,8 +1757,8 @@ struct TargetFilesystemArtifact : public cmGeneratorExpressionNode "be used while evaluating link libraries"); return std::string(); } - context->DependTargets.insert(target->Target); - context->AllTargets.insert(target->Target); + context->DependTargets.insert(target); + context->AllTargets.insert(target); std::string result = TargetFilesystemArtifactResultCreator<ArtifactT>::Create( @@ -1808,7 +1816,7 @@ static const struct ShellPathNode : public cmGeneratorExpressionNode "\"" + parameters.front() + "\" is not an absolute path."); return std::string(); } - cmOutputConverter converter(context->Makefile->GetStateSnapshot()); + cmOutputConverter converter(context->LG->GetStateSnapshot()); return converter.ConvertDirectorySeparatorsForShell(parameters.front()); } } shellPathNode; @@ -1892,7 +1900,7 @@ void reportError(cmGeneratorExpressionContext *context, e << "Error evaluating generator expression:\n" << " " << expr << "\n" << result; - context->Makefile->GetCMakeInstance() + context->LG->GetCMakeInstance() ->IssueMessage(cmake::FATAL_ERROR, e.str(), context->Backtrace); } diff --git a/Source/cmGeneratorExpressionNode.h b/Source/cmGeneratorExpressionNode.h index 847a00a..854811b 100644 --- a/Source/cmGeneratorExpressionNode.h +++ b/Source/cmGeneratorExpressionNode.h @@ -12,8 +12,6 @@ #ifndef cmGeneratorExpressionNode_h #define cmGeneratorExpressionNode_h -#include "cmMakefile.h" - #include "cmGeneratorExpressionEvaluator.h" #include "cmGeneratorExpressionParser.h" #include "cmGeneratorExpressionDAGChecker.h" @@ -54,9 +52,10 @@ struct cmGeneratorExpressionNode ) const = 0; static std::string EvaluateDependentExpression( - std::string const& prop, cmMakefile *makefile, + std::string const& prop, cmLocalGenerator *lg, cmGeneratorExpressionContext *context, - cmTarget const* headTarget, cmTarget const* currentTarget, + const cmGeneratorTarget* headTarget, + const cmGeneratorTarget* currentTarget, cmGeneratorExpressionDAGChecker *dagChecker); static const cmGeneratorExpressionNode* GetNode( diff --git a/Source/cmGeneratorExpressionParser.h b/Source/cmGeneratorExpressionParser.h index 28f1441..5bd6777 100644 --- a/Source/cmGeneratorExpressionParser.h +++ b/Source/cmGeneratorExpressionParser.h @@ -19,8 +19,6 @@ #include "cmListFileCache.h" -class cmMakefile; -class cmTarget; struct cmGeneratorExpressionEvaluator; //---------------------------------------------------------------------------- diff --git a/Source/cmGeneratorTarget.cxx b/Source/cmGeneratorTarget.cxx index 62598f4..cc424b4 100644 --- a/Source/cmGeneratorTarget.cxx +++ b/Source/cmGeneratorTarget.cxx @@ -62,7 +62,7 @@ void reportBadObjLib(std::vector<cmSourceFile*> const& badObjLib, e << "but may contain only sources that compile, header files, and " "other files that would not affect linking of a normal library."; cm->IssueMessage(cmake::FATAL_ERROR, e.str(), - target->Target->GetBacktrace()); + target->GetBacktrace()); } } @@ -155,7 +155,7 @@ struct TagVisitor : Data(data), Target(target), GlobalGenerator(target->GetLocalGenerator()->GetGlobalGenerator()), Header(CM_HEADER_REGEX), - IsObjLib(target->GetType() == cmTarget::OBJECT_LIBRARY) + IsObjLib(target->GetType() == cmState::OBJECT_LIBRARY) { } @@ -172,7 +172,7 @@ struct TagVisitor { DoAccept<IsSameTag<Tag, CustomCommandsTag>::Result>::Do(this->Data, sf); } - else if(this->Target->GetType() == cmTarget::UTILITY) + else if(this->Target->GetType() == cmState::UTILITY) { DoAccept<IsSameTag<Tag, ExtraSourcesTag>::Result>::Do(this->Data, sf); } @@ -269,7 +269,10 @@ cmGeneratorTarget::cmGeneratorTarget(cmTarget* t, cmLocalGenerator* lg) DebugIncludesDone(false), DebugCompileOptionsDone(false), DebugCompileFeaturesDone(false), - DebugCompileDefinitionsDone(false) + DebugCompileDefinitionsDone(false), + DebugSourcesDone(false), + LinkImplementationLanguageIsContextDependent(true), + UtilityItemsDone(false) { this->Makefile = this->Target->GetMakefile(); this->LocalGenerator = lg; @@ -296,6 +299,17 @@ cmGeneratorTarget::cmGeneratorTarget(cmTarget* t, cmLocalGenerator* lg) t->GetCompileDefinitionsEntries(), t->GetCompileDefinitionsBacktraces(), this->CompileDefinitionsEntries); + + CreatePropertyGeneratorExpressions( + t->GetSourceEntries(), + t->GetSourceBacktraces(), + this->SourceEntries, true); + + this->DLLPlatform = (this->Makefile->IsOn("WIN32") || + this->Makefile->IsOn("CYGWIN") || + this->Makefile->IsOn("MINGW")); + + this->PolicyMap = t->PolicyMap; } cmGeneratorTarget::~cmGeneratorTarget() @@ -304,6 +318,7 @@ cmGeneratorTarget::~cmGeneratorTarget() cmDeleteAll(this->CompileOptionsEntries); cmDeleteAll(this->CompileFeaturesEntries); cmDeleteAll(this->CompileDefinitionsEntries); + cmDeleteAll(this->SourceEntries); cmDeleteAll(this->LinkInformation); this->LinkInformation.clear(); } @@ -314,7 +329,7 @@ cmLocalGenerator* cmGeneratorTarget::GetLocalGenerator() const } //---------------------------------------------------------------------------- -int cmGeneratorTarget::GetType() const +cmState::TargetType cmGeneratorTarget::GetType() const { return this->Target->GetType(); } @@ -326,12 +341,88 @@ std::string cmGeneratorTarget::GetName() const } //---------------------------------------------------------------------------- +std::string cmGeneratorTarget::GetExportName() const +{ + const char *exportName = this->GetProperty("EXPORT_NAME"); + + if (exportName && *exportName) + { + if (!cmGeneratorExpression::IsValidTargetName(exportName)) + { + std::ostringstream e; + e << "EXPORT_NAME property \"" << exportName << "\" for \"" + << this->GetName() << "\": is not valid."; + cmSystemTools::Error(e.str().c_str()); + return ""; + } + return exportName; + } + return this->GetName(); +} + +//---------------------------------------------------------------------------- const char *cmGeneratorTarget::GetProperty(const std::string& prop) const { return this->Target->GetProperty(prop); } //---------------------------------------------------------------------------- +const char* cmGeneratorTarget::GetOutputTargetType(bool implib) const +{ + switch(this->GetType()) + { + case cmState::SHARED_LIBRARY: + if(this->IsDLLPlatform()) + { + if(implib) + { + // A DLL import library is treated as an archive target. + return "ARCHIVE"; + } + else + { + // A DLL shared library is treated as a runtime target. + return "RUNTIME"; + } + } + else + { + // For non-DLL platforms shared libraries are treated as + // library targets. + return "LIBRARY"; + } + case cmState::STATIC_LIBRARY: + // Static libraries are always treated as archive targets. + return "ARCHIVE"; + case cmState::MODULE_LIBRARY: + if(implib) + { + // Module libraries are always treated as library targets. + return "ARCHIVE"; + } + else + { + // Module import libraries are treated as archive targets. + return "LIBRARY"; + } + case cmState::EXECUTABLE: + if(implib) + { + // Executable import libraries are treated as archive targets. + return "ARCHIVE"; + } + else + { + // Executables are always treated as runtime targets. + return "RUNTIME"; + } + default: + break; + } + return ""; +} + +//---------------------------------------------------------------------------- std::string cmGeneratorTarget::GetOutputName(const std::string& config, bool implib) const { @@ -347,7 +438,7 @@ std::string cmGeneratorTarget::GetOutputName(const std::string& config, // Compute output name. std::vector<std::string> props; - std::string type = this->Target->GetOutputTargetType(implib); + std::string type = this->GetOutputTargetType(implib); std::string configUpper = cmSystemTools::UpperCase(config); if(!type.empty() && !configUpper.empty()) { @@ -373,7 +464,7 @@ std::string cmGeneratorTarget::GetOutputName(const std::string& config, for(std::vector<std::string>::const_iterator it = props.begin(); it != props.end(); ++it) { - if (const char* outNameProp = this->Target->GetProperty(*it)) + if (const char* outNameProp = this->GetProperty(*it)) { outName = outNameProp; break; @@ -388,35 +479,67 @@ std::string cmGeneratorTarget::GetOutputName(const std::string& config, // Now evaluate genex and update the previously-prepared map entry. cmGeneratorExpression ge; cmsys::auto_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(outName); - i->second = cge->Evaluate(this->Makefile, config); + i->second = cge->Evaluate(this->LocalGenerator, config); } else if(i->second.empty()) { // An empty map entry indicates we have been called recursively // from the above block. - this->Makefile->GetCMakeInstance()->IssueMessage( + this->LocalGenerator->GetCMakeInstance() + ->IssueMessage( cmake::FATAL_ERROR, "Target '" + this->GetName() + "' OUTPUT_NAME depends on itself.", - this->Target->GetBacktrace()); + this->GetBacktrace()); } return i->second; } +void cmGeneratorTarget::AddSource(const std::string& src) +{ + this->Target->AddSource(src); + cmListFileBacktrace lfbt = this->Makefile->GetBacktrace(); + cmGeneratorExpression ge(lfbt); + cmsys::auto_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(src); + cge->SetEvaluateForBuildsystem(true); + this->SourceEntries.push_back( + new TargetPropertyEntry(cge)); + this->SourceFilesMap.clear(); + this->LinkImplementationLanguageIsContextDependent = true; +} + +void cmGeneratorTarget::AddTracedSources(std::vector<std::string> const& srcs) +{ + this->Target->AddTracedSources(srcs); + if (!srcs.empty()) + { + std::string srcFiles = cmJoin(srcs, ";"); + this->SourceFilesMap.clear(); + this->LinkImplementationLanguageIsContextDependent = true; + cmListFileBacktrace lfbt = this->Makefile->GetBacktrace(); + cmGeneratorExpression ge(lfbt); + cmsys::auto_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(srcFiles); + cge->SetEvaluateForBuildsystem(true); + this->SourceEntries.push_back( + new cmGeneratorTarget::TargetPropertyEntry(cge)); + } +} + //---------------------------------------------------------------------------- std::vector<cmSourceFile*> const* cmGeneratorTarget::GetSourceDepends(cmSourceFile const* sf) const { - SourceEntriesType::const_iterator i = this->SourceEntries.find(sf); - if(i != this->SourceEntries.end()) + SourceEntriesType::const_iterator i = this->SourceDepends.find(sf); + if(i != this->SourceDepends.end()) { return &i->second.Depends; } return 0; } -static void handleSystemIncludesDep(cmMakefile *mf, cmTarget const* depTgt, +static void handleSystemIncludesDep(cmLocalGenerator *lg, + cmGeneratorTarget const* depTgt, const std::string& config, - cmTarget *headTarget, + cmGeneratorTarget const* headTarget, cmGeneratorExpressionDAGChecker *dagChecker, std::vector<std::string>& result, bool excludeImported) @@ -426,7 +549,7 @@ static void handleSystemIncludesDep(cmMakefile *mf, cmTarget const* depTgt, { cmGeneratorExpression ge; cmSystemTools::ExpandListArgument(ge.Parse(dirs) - ->Evaluate(mf, + ->Evaluate(lg, config, false, headTarget, depTgt, dagChecker), result); } @@ -440,7 +563,7 @@ static void handleSystemIncludesDep(cmMakefile *mf, cmTarget const* depTgt, { cmGeneratorExpression ge; cmSystemTools::ExpandListArgument(ge.Parse(dirs) - ->Evaluate(mf, + ->Evaluate(lg, config, false, headTarget, depTgt, dagChecker), result); } @@ -449,8 +572,8 @@ static void handleSystemIncludesDep(cmMakefile *mf, cmTarget const* depTgt, #define IMPLEMENT_VISIT_IMPL(DATA, DATATYPE) \ { \ std::vector<cmSourceFile*> sourceFiles; \ - this->Target->GetSourceFiles(sourceFiles, config); \ - TagVisitor<DATA ## Tag DATATYPE> visitor(this, data); \ + this->GetSourceFiles(sourceFiles, config); \ + TagVisitor< DATA##Tag DATATYPE > visitor(this, data); \ for(std::vector<cmSourceFile*>::const_iterator si = sourceFiles.begin(); \ si != sourceFiles.end(); ++si) \ { \ @@ -517,12 +640,12 @@ const char* cmGeneratorTarget::GetFeature(const std::string& feature, std::string featureConfig = feature; featureConfig += "_"; featureConfig += cmSystemTools::UpperCase(config); - if(const char* value = this->Target->GetProperty(featureConfig)) + if(const char* value = this->GetProperty(featureConfig)) { return value; } } - if(const char* value = this->Target->GetProperty(feature)) + if(const char* value = this->GetProperty(feature)) { return value; } @@ -665,7 +788,24 @@ cmGeneratorTarget::GetExpectedXamlSources(std::set<std::string>& srcs, { XamlData data; IMPLEMENT_VISIT_IMPL(Xaml, COMMA cmGeneratorTarget::XamlData) - srcs = data.ExpectedXamlSources; + srcs = data.ExpectedXamlSources; +} + +std::set<cmLinkItem> const& cmGeneratorTarget::GetUtilityItems() const +{ + if(!this->UtilityItemsDone) + { + this->UtilityItemsDone = true; + std::set<std::string> const& utilities = this->GetUtilities(); + for(std::set<std::string>::const_iterator i = utilities.begin(); + i != utilities.end(); ++i) + { + cmGeneratorTarget* gt = + this->LocalGenerator->FindGeneratorTargetToUse(*i); + this->UtilityItems.insert(cmLinkItem(*i, gt)); + } + } + return this->UtilityItems; } //---------------------------------------------------------------------------- @@ -682,7 +822,7 @@ void cmGeneratorTarget const char* cmGeneratorTarget::GetLocation(const std::string& config) const { static std::string location; - if (this->Target->IsImported()) + if (this->IsImported()) { location = this->Target->ImportedGetFullPath(config, false); } @@ -693,11 +833,34 @@ const char* cmGeneratorTarget::GetLocation(const std::string& config) const return location.c_str(); } +std::vector<cmCustomCommand> const& +cmGeneratorTarget::GetPreBuildCommands() const +{ + return this->Target->GetPreBuildCommands(); +} + +std::vector<cmCustomCommand> const& +cmGeneratorTarget::GetPreLinkCommands() const +{ + return this->Target->GetPreLinkCommands(); +} + +std::vector<cmCustomCommand> const& +cmGeneratorTarget::GetPostBuildCommands() const +{ + return this->Target->GetPostBuildCommands(); +} + bool cmGeneratorTarget::IsImported() const { return this->Target->IsImported(); } +bool cmGeneratorTarget::IsImportedGloballyVisible() const +{ + return this->Target->IsImportedGloballyVisible(); +} + //---------------------------------------------------------------------------- const char* cmGeneratorTarget::GetLocationForBuild() const { @@ -709,7 +872,7 @@ const char* cmGeneratorTarget::GetLocationForBuild() const } // Now handle the deprecated build-time configuration location. - location = this->Target->GetDirectory(); + location = this->GetDirectory(); const char* cfgid = this->Makefile->GetDefinition("CMAKE_CFG_INTDIR"); if(cfgid && strcmp(cfgid, ".") != 0) { @@ -717,7 +880,7 @@ const char* cmGeneratorTarget::GetLocationForBuild() const location += cfgid; } - if(this->Target->IsAppBundleOnApple()) + if(this->IsAppBundleOnApple()) { std::string macdir = this->BuildMacContentDirectory("", "", false); @@ -737,7 +900,7 @@ const char* cmGeneratorTarget::GetLocationForBuild() const bool cmGeneratorTarget::IsSystemIncludeDirectory(const std::string& dir, const std::string& config) const { - assert(this->GetType() != cmTarget::INTERFACE_LIBRARY); + assert(this->GetType() != cmState::INTERFACE_LIBRARY); std::string config_upper; if(!config.empty()) { @@ -755,7 +918,7 @@ bool cmGeneratorTarget::IsSystemIncludeDirectory(const std::string& dir, "SYSTEM_INCLUDE_DIRECTORIES", 0, 0); bool excludeImported - = this->Target->GetPropertyAsBool("NO_SYSTEM_FROM_IMPORTED"); + = this->GetPropertyAsBool("NO_SYSTEM_FROM_IMPORTED"); std::vector<std::string> result; for (std::set<std::string>::const_iterator @@ -764,17 +927,17 @@ bool cmGeneratorTarget::IsSystemIncludeDirectory(const std::string& dir, { cmGeneratorExpression ge; cmSystemTools::ExpandListArgument(ge.Parse(*it) - ->Evaluate(this->Makefile, - config, false, this->Target, + ->Evaluate(this->LocalGenerator, + config, false, this, &dagChecker), result); } - std::vector<cmTarget const*> const& deps = + std::vector<cmGeneratorTarget const*> const& deps = this->GetLinkImplementationClosure(config); - for(std::vector<cmTarget const*>::const_iterator + for(std::vector<cmGeneratorTarget const*>::const_iterator li = deps.begin(), le = deps.end(); li != le; ++li) { - handleSystemIncludesDep(this->Makefile, *li, config, this->Target, + handleSystemIncludesDep(this->LocalGenerator, *li, config, this, &dagChecker, result, excludeImported); } @@ -802,10 +965,258 @@ bool cmGeneratorTarget::GetPropertyAsBool(const std::string& prop) const } //---------------------------------------------------------------------------- +static void AddInterfaceEntries( + cmGeneratorTarget const* thisTarget, std::string const& config, + std::string const& prop, + std::vector<cmGeneratorTarget::TargetPropertyEntry*>& entries) +{ + if(cmLinkImplementationLibraries const* impl = + thisTarget->GetLinkImplementationLibraries(config)) + { + for (std::vector<cmLinkImplItem>::const_iterator + it = impl->Libraries.begin(), end = impl->Libraries.end(); + it != end; ++it) + { + if(it->Target) + { + std::string genex = + "$<TARGET_PROPERTY:" + *it + "," + prop + ">"; + cmGeneratorExpression ge(it->Backtrace); + cmsys::auto_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(genex); + cge->SetEvaluateForBuildsystem(true); + entries.push_back( + new cmGeneratorTarget::TargetPropertyEntry(cge, *it)); + } + } + } +} + +//---------------------------------------------------------------------------- +static bool processSources(cmGeneratorTarget const* tgt, + const std::vector<cmGeneratorTarget::TargetPropertyEntry*> &entries, + std::vector<std::string> &srcs, + UNORDERED_SET<std::string> &uniqueSrcs, + cmGeneratorExpressionDAGChecker *dagChecker, + std::string const& config, bool debugSources) +{ + cmMakefile *mf = tgt->Target->GetMakefile(); + + bool contextDependent = false; + + for (std::vector<cmGeneratorTarget::TargetPropertyEntry*>::const_iterator + it = entries.begin(), end = entries.end(); it != end; ++it) + { + cmLinkImplItem const& item = (*it)->LinkImplItem; + std::string const& targetName = item; + std::vector<std::string> entrySources; + cmSystemTools::ExpandListArgument((*it)->ge->Evaluate( + tgt->GetLocalGenerator(), + config, + false, + tgt, + tgt, + dagChecker), + entrySources); + + if ((*it)->ge->GetHadContextSensitiveCondition()) + { + contextDependent = true; + } + + for(std::vector<std::string>::iterator i = entrySources.begin(); + i != entrySources.end(); ++i) + { + std::string& src = *i; + cmSourceFile* sf = mf->GetOrCreateSource(src); + std::string e; + std::string fullPath = sf->GetFullPath(&e); + if(fullPath.empty()) + { + if(!e.empty()) + { + cmake* cm = tgt->GetLocalGenerator()->GetCMakeInstance(); + cm->IssueMessage(cmake::FATAL_ERROR, e, + tgt->GetBacktrace()); + } + return contextDependent; + } + + if (!targetName.empty() && !cmSystemTools::FileIsFullPath(src.c_str())) + { + std::ostringstream err; + if (!targetName.empty()) + { + err << "Target \"" << targetName << "\" contains relative " + "path in its INTERFACE_SOURCES:\n" + " \"" << src << "\""; + } + else + { + err << "Found relative path while evaluating sources of " + "\"" << tgt->GetName() << "\":\n \"" << src << "\"\n"; + } + tgt->GetLocalGenerator()->IssueMessage(cmake::FATAL_ERROR, err.str()); + return contextDependent; + } + src = fullPath; + } + std::string usedSources; + for(std::vector<std::string>::iterator + li = entrySources.begin(); li != entrySources.end(); ++li) + { + std::string src = *li; + + if(uniqueSrcs.insert(src).second) + { + srcs.push_back(src); + if (debugSources) + { + usedSources += " * " + src + "\n"; + } + } + } + if (!usedSources.empty()) + { + tgt->GetLocalGenerator()->GetCMakeInstance()->IssueMessage(cmake::LOG, + std::string("Used sources for target ") + + tgt->GetName() + ":\n" + + usedSources, (*it)->ge->GetBacktrace()); + } + } + return contextDependent; +} + +//---------------------------------------------------------------------------- +void cmGeneratorTarget::GetSourceFiles(std::vector<std::string> &files, + const std::string& config) const +{ + assert(this->GetType() != cmState::INTERFACE_LIBRARY); + + if (!this->LocalGenerator->GetGlobalGenerator()->GetConfigureDoneCMP0026()) + { + // At configure-time, this method can be called as part of getting the + // LOCATION property or to export() a file to be include()d. However + // there is no cmGeneratorTarget at configure-time, so search the SOURCES + // for TARGET_OBJECTS instead for backwards compatibility with OLD + // behavior of CMP0024 and CMP0026 only. + + cmStringRange sourceEntries = this->Target->GetSourceEntries(); + for(cmStringRange::const_iterator + i = sourceEntries.begin(); + i != sourceEntries.end(); ++i) + { + std::string const& entry = *i; + + std::vector<std::string> items; + cmSystemTools::ExpandListArgument(entry, items); + for (std::vector<std::string>::const_iterator + li = items.begin(); li != items.end(); ++li) + { + if(cmHasLiteralPrefix(*li, "$<TARGET_OBJECTS:") && + (*li)[li->size() - 1] == '>') + { + continue; + } + files.push_back(*li); + } + } + return; + } + + std::vector<std::string> debugProperties; + const char *debugProp = + this->Makefile->GetDefinition("CMAKE_DEBUG_TARGET_PROPERTIES"); + if (debugProp) + { + cmSystemTools::ExpandListArgument(debugProp, debugProperties); + } + + bool debugSources = !this->DebugSourcesDone + && std::find(debugProperties.begin(), + debugProperties.end(), + "SOURCES") + != debugProperties.end(); + + if (this->LocalGenerator->GetGlobalGenerator()->GetConfigureDoneCMP0026()) + { + this->DebugSourcesDone = true; + } + + cmGeneratorExpressionDAGChecker dagChecker(this->GetName(), + "SOURCES", 0, 0); + + UNORDERED_SET<std::string> uniqueSrcs; + bool contextDependentDirectSources = processSources(this, + this->SourceEntries, + files, + uniqueSrcs, + &dagChecker, + config, + debugSources); + + std::vector<cmGeneratorTarget::TargetPropertyEntry*> + linkInterfaceSourcesEntries; + + AddInterfaceEntries( + this, config, "INTERFACE_SOURCES", + linkInterfaceSourcesEntries); + + std::vector<std::string>::size_type numFilesBefore = files.size(); + bool contextDependentInterfaceSources = processSources(this, + linkInterfaceSourcesEntries, + files, + uniqueSrcs, + &dagChecker, + config, + debugSources); + + if (!contextDependentDirectSources + && !(contextDependentInterfaceSources && numFilesBefore < files.size())) + { + this->LinkImplementationLanguageIsContextDependent = false; + } + + cmDeleteAll(linkInterfaceSourcesEntries); +} + +//---------------------------------------------------------------------------- void cmGeneratorTarget::GetSourceFiles(std::vector<cmSourceFile*> &files, const std::string& config) const { - this->Target->GetSourceFiles(files, config); + + // Lookup any existing link implementation for this configuration. + std::string key = cmSystemTools::UpperCase(config); + + if(!this->LinkImplementationLanguageIsContextDependent) + { + files = this->SourceFilesMap.begin()->second; + return; + } + + SourceFilesMapType::iterator + it = this->SourceFilesMap.find(key); + if(it != this->SourceFilesMap.end()) + { + files = it->second; + } + else + { + std::vector<std::string> srcs; + this->GetSourceFiles(srcs, config); + + std::set<cmSourceFile*> emitted; + + for(std::vector<std::string>::const_iterator i = srcs.begin(); + i != srcs.end(); ++i) + { + cmSourceFile* sf = this->Makefile->GetOrCreateSource(*i); + if (emitted.insert(sf).second) + { + files.push_back(sf); + } + } + this->SourceFilesMap[key] = files; + } } //---------------------------------------------------------------------------- @@ -821,13 +1232,13 @@ cmGeneratorTarget::GetCompilePDBName(const std::string& config) const std::string configUpper = cmSystemTools::UpperCase(config); std::string configProp = "COMPILE_PDB_NAME_"; configProp += configUpper; - const char* config_name = this->Target->GetProperty(configProp); + const char* config_name = this->GetProperty(configProp); if(config_name && *config_name) { return prefix + config_name + ".pdb"; } - const char* name = this->Target->GetProperty("COMPILE_PDB_NAME"); + const char* name = this->GetProperty("COMPILE_PDB_NAME"); if(name && *name) { return prefix + name + ".pdb"; @@ -844,7 +1255,7 @@ cmGeneratorTarget::GetCompilePDBPath(const std::string& config) const std::string name = this->GetCompilePDBName(config); if(dir.empty() && !name.empty()) { - dir = this->Target->GetPDBDirectory(config); + dir = this->GetPDBDirectory(config); } if(!dir.empty()) { @@ -858,7 +1269,7 @@ bool cmGeneratorTarget::HasSOName(const std::string& config) const { // soname is supported only for shared libraries and modules, // and then only when the platform supports an soname flag. - return ((this->GetType() == cmTarget::SHARED_LIBRARY) && + return ((this->GetType() == cmState::SHARED_LIBRARY) && !this->GetPropertyAsBool("NO_SONAME") && this->Makefile->GetSONameFlag(this->GetLinkerLanguage(config))); } @@ -869,9 +1280,9 @@ cmGeneratorTarget::NeedRelinkBeforeInstall(const std::string& config) const { // Only executables and shared libraries can have an rpath and may // need relinking. - if(this->GetType() != cmTarget::EXECUTABLE && - this->GetType() != cmTarget::SHARED_LIBRARY && - this->GetType() != cmTarget::MODULE_LIBRARY) + if(this->GetType() != cmState::EXECUTABLE && + this->GetType() != cmState::SHARED_LIBRARY && + this->GetType() != cmState::MODULE_LIBRARY) { return false; } @@ -926,16 +1337,16 @@ cmGeneratorTarget::NeedRelinkBeforeInstall(const std::string& config) const // will likely change between the build tree and install tree and // this target must be relinked. return this->HaveBuildTreeRPATH(config) - || this->Target->HaveInstallTreeRPATH(); + || this->HaveInstallTreeRPATH(); } //---------------------------------------------------------------------------- bool cmGeneratorTarget::IsChrpathUsed(const std::string& config) const { // Only certain target types have an rpath. - if(!(this->GetType() == cmTarget::SHARED_LIBRARY || - this->GetType() == cmTarget::MODULE_LIBRARY || - this->GetType() == cmTarget::EXECUTABLE)) + if(!(this->GetType() == cmState::SHARED_LIBRARY || + this->GetType() == cmState::MODULE_LIBRARY || + this->GetType() == cmState::EXECUTABLE)) { return false; } @@ -996,14 +1407,144 @@ bool cmGeneratorTarget::IsChrpathUsed(const std::string& config) const return false; } +//---------------------------------------------------------------------------- +bool cmGeneratorTarget::IsImportedSharedLibWithoutSOName( + const std::string& config) const +{ + if(this->IsImported() && this->GetType() == cmState::SHARED_LIBRARY) + { + if(cmGeneratorTarget::ImportInfo const* info = + this->GetImportInfo(config)) + { + return info->NoSOName; + } + } + return false; +} + +//---------------------------------------------------------------------------- +bool cmGeneratorTarget::HasMacOSXRpathInstallNameDir( + const std::string& config) const +{ + bool install_name_is_rpath = false; + bool macosx_rpath = false; + + if(!this->IsImported()) + { + if(this->GetType() != cmState::SHARED_LIBRARY) + { + return false; + } + const char* install_name = this->GetProperty("INSTALL_NAME_DIR"); + bool use_install_name = + this->GetPropertyAsBool("BUILD_WITH_INSTALL_RPATH"); + if(install_name && use_install_name && + std::string(install_name) == "@rpath") + { + install_name_is_rpath = true; + } + else if(install_name && use_install_name) + { + return false; + } + if(!install_name_is_rpath) + { + macosx_rpath = this->MacOSXRpathInstallNameDirDefault(); + } + } + else + { + // Lookup the imported soname. + if(cmGeneratorTarget::ImportInfo const* info = + this->GetImportInfo(config)) + { + if(!info->NoSOName && !info->SOName.empty()) + { + if(info->SOName.find("@rpath/") == 0) + { + install_name_is_rpath = true; + } + } + else + { + std::string install_name; + cmSystemTools::GuessLibraryInstallName(info->Location, install_name); + if(install_name.find("@rpath") != std::string::npos) + { + install_name_is_rpath = true; + } + } + } + } + + if(!install_name_is_rpath && !macosx_rpath) + { + return false; + } + + if(!this->Makefile->IsSet("CMAKE_SHARED_LIBRARY_RUNTIME_C_FLAG")) + { + std::ostringstream w; + w << "Attempting to use"; + if(macosx_rpath) + { + w << " MACOSX_RPATH"; + } + else + { + w << " @rpath"; + } + w << " without CMAKE_SHARED_LIBRARY_RUNTIME_C_FLAG being set."; + w << " This could be because you are using a Mac OS X version"; + w << " less than 10.5 or because CMake's platform configuration is"; + w << " corrupt."; + cmake* cm = this->LocalGenerator->GetCMakeInstance(); + cm->IssueMessage(cmake::FATAL_ERROR, w.str(), + this->GetBacktrace()); + } + + return true; +} + +//---------------------------------------------------------------------------- +bool cmGeneratorTarget::MacOSXRpathInstallNameDirDefault() const +{ + // we can't do rpaths when unsupported + if(!this->Makefile->IsSet("CMAKE_SHARED_LIBRARY_RUNTIME_C_FLAG")) + { + return false; + } + + const char* macosx_rpath_str = this->GetProperty("MACOSX_RPATH"); + if(macosx_rpath_str) + { + return this->GetPropertyAsBool("MACOSX_RPATH"); + } + + cmPolicies::PolicyStatus cmp0042 = this->GetPolicyStatusCMP0042(); + + if(cmp0042 == cmPolicies::WARN) + { + this->LocalGenerator->GetGlobalGenerator()-> + AddCMP0042WarnTarget(this->GetName()); + } + + if(cmp0042 == cmPolicies::NEW) + { + return true; + } + + return false; +} //---------------------------------------------------------------------------- std::string cmGeneratorTarget::GetSOName(const std::string& config) const { - if(this->Target->IsImported()) + if(this->IsImported()) { // Lookup the imported soname. - if(cmTarget::ImportInfo const* info = this->Target->GetImportInfo(config)) + if(cmGeneratorTarget::ImportInfo const* info = + this->GetImportInfo(config)) { if(info->NoSOName) { @@ -1060,9 +1601,9 @@ cmGeneratorTarget::GetAppBundleDirectory(const std::string& config, //---------------------------------------------------------------------------- bool cmGeneratorTarget::IsBundleOnApple() const { - return this->Target->IsFrameworkOnApple() - || this->Target->IsAppBundleOnApple() - || this->Target->IsCFBundleOnApple(); + return this->IsFrameworkOnApple() + || this->IsAppBundleOnApple() + || this->IsCFBundleOnApple(); } //---------------------------------------------------------------------------- @@ -1072,10 +1613,10 @@ std::string cmGeneratorTarget::GetCFBundleDirectory(const std::string& config, std::string fpath; fpath += this->GetOutputName(config, false); fpath += "."; - const char *ext = this->Target->GetProperty("BUNDLE_EXTENSION"); + const char *ext = this->GetProperty("BUNDLE_EXTENSION"); if (!ext) { - if (this->Target->IsXCTestOnApple()) + if (this->IsXCTestOnApple()) { ext = "xctest"; } @@ -1105,7 +1646,7 @@ cmGeneratorTarget::GetFrameworkDirectory(const std::string& config, if(!rootDir && !this->Makefile->PlatformIsAppleIos()) { fpath += "/Versions/"; - fpath += this->Target->GetFrameworkVersion(); + fpath += this->GetFrameworkVersion(); } return fpath; } @@ -1114,9 +1655,9 @@ cmGeneratorTarget::GetFrameworkDirectory(const std::string& config, std::string cmGeneratorTarget::GetFullName(const std::string& config, bool implib) const { - if(this->Target->IsImported()) + if(this->IsImported()) { - return this->Target->GetFullNameImported(config, implib); + return this->GetFullNameImported(config, implib); } else { @@ -1142,13 +1683,13 @@ cmGeneratorTarget::GetInstallNameDirForBuildTree( !this->GetPropertyAsBool("SKIP_BUILD_RPATH")) { std::string dir; - if(this->Target->MacOSXRpathInstallNameDirDefault()) + if(this->MacOSXRpathInstallNameDirDefault()) { dir = "@rpath"; } else { - dir = this->Target->GetDirectory(config); + dir = this->GetDirectory(config); } dir += "/"; return dir; @@ -1178,7 +1719,7 @@ std::string cmGeneratorTarget::GetInstallNameDirForInstallTree() const } if(!install_name_dir) { - if(this->Target->MacOSXRpathInstallNameDirDefault()) + if(this->MacOSXRpathInstallNameDirDefault()) { dir = "@rpath/"; } @@ -1191,6 +1732,63 @@ std::string cmGeneratorTarget::GetInstallNameDirForInstallTree() const } } +cmListFileBacktrace cmGeneratorTarget::GetBacktrace() const +{ + return this->Target->GetBacktrace(); +} + +const std::vector<std::string>&cmGeneratorTarget::GetLinkDirectories() const +{ + return this->Target->GetLinkDirectories(); +} + +const std::set<std::string>& cmGeneratorTarget::GetUtilities() const +{ + return this->Target->GetUtilities(); +} + +const cmListFileBacktrace* +cmGeneratorTarget::GetUtilityBacktrace(const std::string& u) const +{ + return this->Target->GetUtilityBacktrace(u); +} + +//---------------------------------------------------------------------------- +bool cmGeneratorTarget::HaveWellDefinedOutputFiles() const +{ + return + this->GetType() == cmState::STATIC_LIBRARY || + this->GetType() == cmState::SHARED_LIBRARY || + this->GetType() == cmState::MODULE_LIBRARY || + this->GetType() == cmState::EXECUTABLE; +} + +//---------------------------------------------------------------------------- +const char* cmGeneratorTarget::GetExportMacro() const +{ + // Define the symbol for targets that export symbols. + if(this->GetType() == cmState::SHARED_LIBRARY || + this->GetType() == cmState::MODULE_LIBRARY || + this->IsExecutableWithExports()) + { + if(const char* custom_export_name = this->GetProperty("DEFINE_SYMBOL")) + { + this->ExportMacro = custom_export_name; + } + else + { + std::string in = this->GetName(); + in += "_EXPORTS"; + this->ExportMacro = cmSystemTools::MakeCidentifier(in); + } + return this->ExportMacro.c_str(); + } + else + { + return 0; + } +} + //---------------------------------------------------------------------------- class cmTargetCollectLinkLanguages { @@ -1198,10 +1796,10 @@ public: cmTargetCollectLinkLanguages(cmGeneratorTarget const* target, const std::string& config, UNORDERED_SET<std::string>& languages, - cmTarget const* head): + cmGeneratorTarget const* head): Config(config), Languages(languages), HeadTarget(head), - Makefile(target->Target->GetMakefile()), Target(target) - { this->Visited.insert(target->Target); } + Target(target) + { this->Visited.insert(target); } void Visit(cmLinkItem const& item) { @@ -1212,7 +1810,8 @@ public: bool noMessage = false; cmake::MessageType messageType = cmake::FATAL_ERROR; std::stringstream e; - switch(this->Makefile->GetPolicyStatus(cmPolicies::CMP0028)) + switch(this->Target->GetLocalGenerator() + ->GetPolicyStatus(cmPolicies::CMP0028)) { case cmPolicies::WARN: { @@ -1236,8 +1835,8 @@ public: << "\" but the target was not found. Perhaps a find_package() " "call is missing for an IMPORTED target, or an ALIAS target is " "missing?"; - this->Makefile->GetCMakeInstance()->IssueMessage( - messageType, e.str(), this->Target->Target->GetBacktrace()); + this->Target->GetLocalGenerator()->GetCMakeInstance()->IssueMessage( + messageType, e.str(), this->Target->GetBacktrace()); } } return; @@ -1246,11 +1845,8 @@ public: { return; } - cmGeneratorTarget* gtgt = - this->Target->GetLocalGenerator()->GetGlobalGenerator() - ->GetGeneratorTarget(item.Target); cmLinkInterface const* iface = - gtgt->GetLinkInterface(this->Config, this->HeadTarget); + item.Target->GetLinkInterface(this->Config, this->HeadTarget); if(!iface) { return; } for(std::vector<std::string>::const_iterator @@ -1268,10 +1864,9 @@ public: private: std::string Config; UNORDERED_SET<std::string>& Languages; - cmTarget const* HeadTarget; - cmMakefile* Makefile; + cmGeneratorTarget const* HeadTarget; const cmGeneratorTarget* Target; - std::set<cmTarget const*> Visited; + std::set<cmGeneratorTarget const*> Visited; }; //---------------------------------------------------------------------------- @@ -1296,14 +1891,12 @@ class cmTargetSelectLinker { int Preference; cmGeneratorTarget const* Target; - cmMakefile* Makefile; cmGlobalGenerator* GG; std::set<std::string> Preferred; public: cmTargetSelectLinker(cmGeneratorTarget const* target) : Preference(0), Target(target) { - this->Makefile = this->Target->Makefile; this->GG = this->Target->GetLocalGenerator()->GetGlobalGenerator(); } void Consider(const char* lang) @@ -1337,9 +1930,9 @@ public: e << " " << *li << "\n"; } e << "Set the LINKER_LANGUAGE property for this target."; - cmake* cm = this->Makefile->GetCMakeInstance(); + cmake* cm = this->Target->GetLocalGenerator()->GetCMakeInstance(); cm->IssueMessage(cmake::FATAL_ERROR, e.str(), - this->Target->Target->GetBacktrace()); + this->Target->GetBacktrace()); } return *this->Preferred.begin(); } @@ -1361,7 +1954,7 @@ void cmGeneratorTarget::ComputeLinkClosure(const std::string& config, } // Add interface languages from linked targets. - cmTargetCollectLinkLanguages cll(this, config, languages, this->Target); + cmTargetCollectLinkLanguages cll(this, config, languages, this); for(std::vector<cmLinkImplItem>::const_iterator li = impl->Libraries.begin(); li != impl->Libraries.end(); ++li) { @@ -1428,15 +2021,15 @@ cmGeneratorTarget::BuildMacContentDirectory(const std::string& base, bool contentOnly) const { std::string fpath = base; - if(this->Target->IsAppBundleOnApple()) + if(this->IsAppBundleOnApple()) { fpath += this->GetAppBundleDirectory(config, contentOnly); } - if(this->Target->IsFrameworkOnApple()) + if(this->IsFrameworkOnApple()) { fpath += this->GetFrameworkDirectory(config, contentOnly); } - if(this->Target->IsCFBundleOnApple()) + if(this->IsCFBundleOnApple()) { fpath += this->GetCFBundleDirectory(config, contentOnly); } @@ -1449,10 +2042,10 @@ cmGeneratorTarget::GetMacContentDirectory(const std::string& config, bool implib) const { // Start with the output directory for the target. - std::string fpath = this->Target->GetDirectory(config, implib); + std::string fpath = this->GetDirectory(config, implib); fpath += "/"; bool contentOnly = true; - if(this->Target->IsFrameworkOnApple()) + if(this->IsFrameworkOnApple()) { // additional files with a framework go into the version specific // directory @@ -1473,12 +2066,12 @@ cmGeneratorTarget::CompileInfo const* cmGeneratorTarget::GetCompileInfo( return 0; } - if(this->GetType() > cmTarget::OBJECT_LIBRARY) + if(this->GetType() > cmState::OBJECT_LIBRARY) { std::string msg = "cmTarget::GetCompileInfo called for "; msg += this->GetName(); msg += " which has type "; - msg += cmTarget::GetTargetTypeName(this->Target->GetType()); + msg += cmState::GetTargetTypeName(this->GetType()); this->LocalGenerator->IssueMessage(cmake::INTERNAL_ERROR, msg); return 0; } @@ -1494,8 +2087,7 @@ cmGeneratorTarget::CompileInfo const* cmGeneratorTarget::GetCompileInfo( if(i == this->CompileInfoMap.end()) { CompileInfo info; - this->Target - ->ComputePDBOutputDir("COMPILE_PDB", config, info.CompilePdbDir); + this->ComputePDBOutputDir("COMPILE_PDB", config, info.CompilePdbDir); CompileInfoMapType::value_type entry(config_upper, info); i = this->CompileInfoMap.insert(entry).first; } @@ -1503,12 +2095,23 @@ cmGeneratorTarget::CompileInfo const* cmGeneratorTarget::GetCompileInfo( } //---------------------------------------------------------------------------- -std::string +cmSourceFile const* cmGeneratorTarget::GetModuleDefinitionFile(const std::string& config) const { - std::string data; - IMPLEMENT_VISIT_IMPL(ModuleDefinitionFile, COMMA std::string) - return data; + std::vector<cmSourceFile const*> data; + IMPLEMENT_VISIT_IMPL(ModuleDefinitionFile, + COMMA std::vector<cmSourceFile const*>) + if(!data.empty()) + { + return data.front(); + } + + return 0; +} + +bool cmGeneratorTarget::IsDLLPlatform() const +{ + return this->DLLPlatform; } //---------------------------------------------------------------------------- @@ -1518,27 +2121,26 @@ cmGeneratorTarget::UseObjectLibraries(std::vector<std::string>& objs, { std::vector<cmSourceFile const*> objectFiles; this->GetExternalObjects(objectFiles, config); - std::vector<cmTarget*> objectLibraries; + std::vector<cmGeneratorTarget*> objectLibraries; for(std::vector<cmSourceFile const*>::const_iterator it = objectFiles.begin(); it != objectFiles.end(); ++it) { std::string objLib = (*it)->GetObjectLibrary(); - if (cmTarget* tgt = this->Makefile->FindTargetToUse(objLib)) + if (cmGeneratorTarget* tgt = + this->LocalGenerator->FindGeneratorTargetToUse(objLib)) { objectLibraries.push_back(tgt); } } - std::vector<cmTarget*>::const_iterator end + std::vector<cmGeneratorTarget*>::const_iterator end = cmRemoveDuplicates(objectLibraries); - for(std::vector<cmTarget*>::const_iterator + for(std::vector<cmGeneratorTarget*>::const_iterator ti = objectLibraries.begin(); ti != end; ++ti) { - cmTarget* objLib = *ti; - cmGeneratorTarget* ogt = - this->GlobalGenerator->GetGeneratorTarget(objLib); + cmGeneratorTarget* ogt = *ti; std::vector<cmSourceFile const*> objectSources; ogt->GetObjectSources(objectSources, config); for(std::vector<cmSourceFile const*>::const_iterator @@ -1569,28 +2171,27 @@ void cmGeneratorTarget::GetAutoUicOptions(std::vector<std::string> &result, this->GetName(), "AUTOUIC_OPTIONS", 0, 0); cmSystemTools::ExpandListArgument(ge.Parse(prop) - ->Evaluate(this->Makefile, + ->Evaluate(this->LocalGenerator, config, false, - this->Target, + this, &dagChecker), result); } //---------------------------------------------------------------------------- void processILibs(const std::string& config, - cmTarget const* headTarget, + cmGeneratorTarget const* headTarget, cmLinkItem const& item, cmGlobalGenerator* gg, - std::vector<cmTarget const*>& tgts, - std::set<cmTarget const*>& emitted) + std::vector<cmGeneratorTarget const*>& tgts, + std::set<cmGeneratorTarget const*>& emitted) { if (item.Target && emitted.insert(item.Target).second) { tgts.push_back(item.Target); - cmGeneratorTarget* gt = gg->GetGeneratorTarget(item.Target); if(cmLinkInterfaceLibraries const* iface = - gt->GetLinkInterfaceLibraries(config, headTarget, true)) + item.Target->GetLinkInterfaceLibraries(config, headTarget, true)) { for(std::vector<cmLinkItem>::const_iterator it = iface->Libraries.begin(); @@ -1603,7 +2204,7 @@ void processILibs(const std::string& config, } //---------------------------------------------------------------------------- -const std::vector<const cmTarget*>& +const std::vector<const cmGeneratorTarget*>& cmGeneratorTarget::GetLinkImplementationClosure( const std::string& config) const { @@ -1612,16 +2213,16 @@ cmGeneratorTarget::GetLinkImplementationClosure( if(!tgts.Done) { tgts.Done = true; - std::set<cmTarget const*> emitted; + std::set<cmGeneratorTarget const*> emitted; cmLinkImplementationLibraries const* impl - = this->Target->GetLinkImplementationLibraries(config); + = this->GetLinkImplementationLibraries(config); for(std::vector<cmLinkImplItem>::const_iterator it = impl->Libraries.begin(); it != impl->Libraries.end(); ++it) { - processILibs(config, this->Target, *it, + processILibs(config, this, *it, this->LocalGenerator->GetGlobalGenerator(), tgts , emitted); } @@ -1636,9 +2237,9 @@ public: cmTargetTraceDependencies(cmGeneratorTarget* target); void Trace(); private: - cmTarget* Target; cmGeneratorTarget* GeneratorTarget; cmMakefile* Makefile; + cmLocalGenerator* LocalGenerator; cmGlobalGenerator const* GlobalGenerator; typedef cmGeneratorTarget::SourceEntry SourceEntry; SourceEntry* CurrentEntry; @@ -1662,15 +2263,16 @@ private: //---------------------------------------------------------------------------- cmTargetTraceDependencies ::cmTargetTraceDependencies(cmGeneratorTarget* target): - Target(target->Target), GeneratorTarget(target) + GeneratorTarget(target) { // Convenience. - this->Makefile = this->Target->GetMakefile(); - this->GlobalGenerator = target->GetLocalGenerator()->GetGlobalGenerator(); + this->Makefile = target->Target->GetMakefile(); + this->LocalGenerator = target->GetLocalGenerator(); + this->GlobalGenerator = this->LocalGenerator->GetGlobalGenerator(); this->CurrentEntry = 0; // Queue all the source files already specified for the target. - if (this->Target->GetType() != cmTarget::INTERFACE_LIBRARY) + if (target->GetType() != cmState::INTERFACE_LIBRARY) { std::vector<std::string> configs; this->Makefile->GetConfigurations(configs); @@ -1683,14 +2285,14 @@ cmTargetTraceDependencies ci != configs.end(); ++ci) { std::vector<cmSourceFile*> sources; - this->Target->GetSourceFiles(sources, *ci); + this->GeneratorTarget->GetSourceFiles(sources, *ci); for(std::vector<cmSourceFile*>::const_iterator si = sources.begin(); si != sources.end(); ++si) { cmSourceFile* sf = *si; - const std::set<cmTarget const*> tgts = + const std::set<cmGeneratorTarget const*> tgts = this->GlobalGenerator->GetFilenameTargetDepends(sf); - if (tgts.find(this->Target) != tgts.end()) + if (tgts.find(this->GeneratorTarget) != tgts.end()) { std::ostringstream e; e << "Evaluation output file\n \"" << sf->GetFullPath() @@ -1709,9 +2311,12 @@ cmTargetTraceDependencies } // Queue pre-build, pre-link, and post-build rule dependencies. - this->CheckCustomCommands(this->Target->GetPreBuildCommands()); - this->CheckCustomCommands(this->Target->GetPreLinkCommands()); - this->CheckCustomCommands(this->Target->GetPostBuildCommands()); + this->CheckCustomCommands( + this->GeneratorTarget->GetPreBuildCommands()); + this->CheckCustomCommands( + this->GeneratorTarget->GetPreLinkCommands()); + this->CheckCustomCommands( + this->GeneratorTarget->GetPostBuildCommands()); } //---------------------------------------------------------------------------- @@ -1723,7 +2328,7 @@ void cmTargetTraceDependencies::Trace() // Get the next source from the queue. cmSourceFile* sf = this->SourceQueue.front(); this->SourceQueue.pop(); - this->CurrentEntry = &this->GeneratorTarget->SourceEntries[sf]; + this->CurrentEntry = &this->GeneratorTarget->SourceDepends[sf]; // Queue dependencies added explicitly by the user. if(const char* additionalDeps = sf->GetProperty("OBJECT_DEPENDS")) @@ -1755,7 +2360,7 @@ void cmTargetTraceDependencies::Trace() } this->CurrentEntry = 0; - this->Target->AddTracedSources(this->NewSources); + this->GeneratorTarget->AddTracedSources(this->NewSources); } //---------------------------------------------------------------------------- @@ -1820,15 +2425,16 @@ bool cmTargetTraceDependencies::IsUtility(std::string const& dep) // Check for a target with this name. if(cmGeneratorTarget* t - = this->Makefile->FindGeneratorTargetToUse(util)) + = this->GeneratorTarget-> + GetLocalGenerator()->FindGeneratorTargetToUse(util)) { // If we find the target and the dep was given as a full path, // then make sure it was not a full path to something else, and // the fact that the name matched a target was just a coincidence. if(cmSystemTools::FileIsFullPath(dep.c_str())) { - if(t->GetType() >= cmTarget::EXECUTABLE && - t->GetType() <= cmTarget::MODULE_LIBRARY) + if(t->GetType() >= cmState::EXECUTABLE && + t->GetType() <= cmState::MODULE_LIBRARY) { // This is really only for compatibility so we do not need to // worry about configuration names and output names. @@ -1839,7 +2445,7 @@ bool cmTargetTraceDependencies::IsUtility(std::string const& dep) tLocation = cmSystemTools::CollapseFullPath(tLocation); if(depLocation == tLocation) { - this->Target->AddUtility(util); + this->GeneratorTarget->Target->AddUtility(util); return true; } } @@ -1848,7 +2454,7 @@ bool cmTargetTraceDependencies::IsUtility(std::string const& dep) { // The original name of the dependency was not a full path. It // must name a target, so add the target-level dependency. - this->Target->AddUtility(util); + this->GeneratorTarget->Target->AddUtility(util); return true; } } @@ -1867,22 +2473,23 @@ cmTargetTraceDependencies cmGeneratorExpression ge(cc.GetBacktrace()); // Add target-level dependencies referenced by generator expressions. - std::set<cmTarget*> targets; + std::set<cmGeneratorTarget*> targets; for(cmCustomCommandLines::const_iterator cit = cc.GetCommandLines().begin(); cit != cc.GetCommandLines().end(); ++cit) { std::string const& command = *cit->begin(); // Check for a target with this name. - if(cmTarget* t = this->Makefile->FindTargetToUse(command)) + if(cmGeneratorTarget* t = + this->LocalGenerator->FindGeneratorTargetToUse(command)) { - if(t->GetType() == cmTarget::EXECUTABLE) + if(t->GetType() == cmState::EXECUTABLE) { // The command refers to an executable target built in // this project. Add the target-level dependency to make // sure the executable is up to date before this custom // command possibly runs. - this->Target->AddUtility(command); + this->GeneratorTarget->Target->AddUtility(command); } } @@ -1892,16 +2499,16 @@ cmTargetTraceDependencies { const cmsys::auto_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(*cli); - cge->Evaluate(this->Makefile, "", true); - std::set<cmTarget*> geTargets = cge->GetTargets(); + cge->Evaluate(this->GeneratorTarget->GetLocalGenerator(), "", true); + std::set<cmGeneratorTarget*> geTargets = cge->GetTargets(); targets.insert(geTargets.begin(), geTargets.end()); } } - for(std::set<cmTarget*>::iterator ti = targets.begin(); + for(std::set<cmGeneratorTarget*>::iterator ti = targets.begin(); ti != targets.end(); ++ti) { - this->Target->AddUtility((*ti)->GetName()); + this->GeneratorTarget->Target->AddUtility((*ti)->GetName()); } // Queue the custom command dependencies. @@ -1964,7 +2571,7 @@ void cmGeneratorTarget::TraceDependencies() // would find nothing anyway, but when building CMake itself the "install" // target command ends up referencing the "cmake" target but we do not // really want the dependency because "install" depend on "all" anyway. - if(this->GetType() == cmTarget::GLOBAL_TARGET) + if(this->GetType() == cmState::GLOBAL_TARGET) { return; } @@ -1993,11 +2600,11 @@ void cmGeneratorTarget::GetAppleArchs(const std::string& config, { std::string defVarName = "OSX_ARCHITECTURES_"; defVarName += cmSystemTools::UpperCase(config); - archs = this->Target->GetProperty(defVarName); + archs = this->GetProperty(defVarName); } if(!archs) { - archs = this->Target->GetProperty("OSX_ARCHITECTURES"); + archs = this->GetProperty("OSX_ARCHITECTURES"); } if(archs) { @@ -2012,7 +2619,7 @@ cmGeneratorTarget::GetCreateRuleVariable(std::string const& lang, { switch(this->GetType()) { - case cmTarget::STATIC_LIBRARY: + case cmState::STATIC_LIBRARY: { std::string var = "CMAKE_" + lang + "_CREATE_STATIC_LIBRARY"; if(this->GetFeatureAsBool( @@ -2026,11 +2633,11 @@ cmGeneratorTarget::GetCreateRuleVariable(std::string const& lang, } return var; } - case cmTarget::SHARED_LIBRARY: + case cmState::SHARED_LIBRARY: return "CMAKE_" + lang + "_CREATE_SHARED_LIBRARY"; - case cmTarget::MODULE_LIBRARY: + case cmState::MODULE_LIBRARY: return "CMAKE_" + lang + "_CREATE_SHARED_MODULE"; - case cmTarget::EXECUTABLE: + case cmState::EXECUTABLE: return "CMAKE_" + lang + "_LINK_EXECUTABLE"; default: break; @@ -2046,8 +2653,6 @@ static void processIncludeDirectories(cmGeneratorTarget const* tgt, const std::string& config, bool debugIncludes, const std::string& language) { - cmMakefile *mf = tgt->Target->GetMakefile(); - for (std::vector<cmGeneratorTarget::TargetPropertyEntry*>::const_iterator it = entries.begin(), end = entries.end(); it != end; ++it) { @@ -2056,10 +2661,11 @@ static void processIncludeDirectories(cmGeneratorTarget const* tgt, bool const fromImported = item.Target && item.Target->IsImported(); bool const checkCMP0027 = item.FromGenex; std::vector<std::string> entryIncludes; - cmSystemTools::ExpandListArgument((*it)->ge->Evaluate(mf, + cmSystemTools::ExpandListArgument((*it)->ge->Evaluate( + tgt->GetLocalGenerator(), config, false, - tgt->Target, + tgt, dagChecker, language), entryIncludes); @@ -2074,7 +2680,7 @@ static void processIncludeDirectories(cmGeneratorTarget const* tgt, cmake::MessageType messageType = cmake::FATAL_ERROR; if (checkCMP0027) { - switch(tgt->Target->GetPolicyStatusCMP0027()) + switch(tgt->GetPolicyStatusCMP0027()) { case cmPolicies::WARN: e << cmPolicies::GetPolicyWarning(cmPolicies::CMP0027) << "\n"; @@ -2113,7 +2719,7 @@ static void processIncludeDirectories(cmGeneratorTarget const* tgt, } else { - switch(tgt->Target->GetPolicyStatusCMP0021()) + switch(tgt->GetPolicyStatusCMP0021()) { case cmPolicies::WARN: { @@ -2159,7 +2765,7 @@ static void processIncludeDirectories(cmGeneratorTarget const* tgt, } if (!usedIncludes.empty()) { - mf->GetCMakeInstance()->IssueMessage(cmake::LOG, + tgt->GetLocalGenerator()->GetCMakeInstance()->IssueMessage(cmake::LOG, std::string("Used includes for target ") + tgt->GetName() + ":\n" + usedIncludes, (*it)->ge->GetBacktrace()); @@ -2167,34 +2773,6 @@ static void processIncludeDirectories(cmGeneratorTarget const* tgt, } } - -//---------------------------------------------------------------------------- -static void AddInterfaceEntries( - cmGeneratorTarget const* thisTarget, std::string const& config, - std::string const& prop, - std::vector<cmGeneratorTarget::TargetPropertyEntry*>& entries) -{ - if(cmLinkImplementationLibraries const* impl = - thisTarget->Target->GetLinkImplementationLibraries(config)) - { - for (std::vector<cmLinkImplItem>::const_iterator - it = impl->Libraries.begin(), end = impl->Libraries.end(); - it != end; ++it) - { - if(it->Target) - { - std::string genex = - "$<TARGET_PROPERTY:" + *it + "," + prop + ">"; - cmGeneratorExpression ge(it->Backtrace); - cmsys::auto_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(genex); - cge->SetEvaluateForBuildsystem(true); - entries.push_back( - new cmGeneratorTarget::TargetPropertyEntry(cge, *it)); - } - } - } -} - //---------------------------------------------------------------------------- std::vector<std::string> cmGeneratorTarget::GetIncludeDirectories(const std::string& config, @@ -2243,7 +2821,7 @@ cmGeneratorTarget::GetIncludeDirectories(const std::string& config, if(this->Makefile->IsOn("APPLE")) { cmLinkImplementationLibraries const* impl = - this->Target->GetLinkImplementationLibraries(config); + this->GetLinkImplementationLibraries(config); for(std::vector<cmLinkImplItem>::const_iterator it = impl->Libraries.begin(); it != impl->Libraries.end(); ++it) @@ -2290,16 +2868,15 @@ static void processCompileOptionsInternal(cmGeneratorTarget const* tgt, const std::string& config, bool debugOptions, const char *logName, std::string const& language) { - cmMakefile *mf = tgt->Target->GetMakefile(); - for (std::vector<cmGeneratorTarget::TargetPropertyEntry*>::const_iterator it = entries.begin(), end = entries.end(); it != end; ++it) { std::vector<std::string> entryOptions; - cmSystemTools::ExpandListArgument((*it)->ge->Evaluate(mf, + cmSystemTools::ExpandListArgument((*it)->ge->Evaluate( + tgt->GetLocalGenerator(), config, false, - tgt->Target, + tgt, dagChecker, language), entryOptions); @@ -2320,7 +2897,7 @@ static void processCompileOptionsInternal(cmGeneratorTarget const* tgt, } if (!usedOptions.empty()) { - mf->GetCMakeInstance()->IssueMessage(cmake::LOG, + tgt->GetLocalGenerator()->GetCMakeInstance()->IssueMessage(cmake::LOG, std::string("Used compile ") + logName + std::string(" for target ") + tgt->GetName() + ":\n" @@ -2528,7 +3105,7 @@ void cmGeneratorTarget::GetCompileDefinitions(std::vector<std::string> &list, { std::string configPropName = "COMPILE_DEFINITIONS_" + cmSystemTools::UpperCase(config); - const char *configProp = this->Target->GetProperty(configPropName); + const char *configProp = this->GetProperty(configPropName); if (configProp) { switch(this->Makefile->GetPolicyStatus(cmPolicies::CMP0043)) @@ -2573,7 +3150,7 @@ void cmGeneratorTarget::GetCompileDefinitions(std::vector<std::string> &list, void cmGeneratorTarget::ComputeTargetManifest( const std::string& config) const { - if (this->Target->IsImported()) + if (this->IsImported()) { return; } @@ -2585,13 +3162,13 @@ void cmGeneratorTarget::ComputeTargetManifest( std::string realName; std::string impName; std::string pdbName; - if(this->GetType() == cmTarget::EXECUTABLE) + if(this->GetType() == cmState::EXECUTABLE) { this->GetExecutableNames(name, realName, impName, pdbName, config); } - else if(this->GetType() == cmTarget::STATIC_LIBRARY || - this->GetType() == cmTarget::SHARED_LIBRARY || - this->GetType() == cmTarget::MODULE_LIBRARY) + else if(this->GetType() == cmState::STATIC_LIBRARY || + this->GetType() == cmState::SHARED_LIBRARY || + this->GetType() == cmState::MODULE_LIBRARY) { this->GetLibraryNames(name, soName, realName, impName, pdbName, config); @@ -2602,7 +3179,7 @@ void cmGeneratorTarget::ComputeTargetManifest( } // Get the directory. - std::string dir = this->Target->GetDirectory(config, false); + std::string dir = this->GetDirectory(config, false); // Add each name. std::string f; @@ -2636,7 +3213,7 @@ void cmGeneratorTarget::ComputeTargetManifest( } if(!impName.empty()) { - f = this->Target->GetDirectory(config, true); + f = this->GetDirectory(config, true); f += "/"; f += impName; gg->AddToManifest(f); @@ -2647,7 +3224,7 @@ void cmGeneratorTarget::ComputeTargetManifest( std::string cmGeneratorTarget::GetFullPath(const std::string& config, bool implib, bool realname) const { - if(this->Target->IsImported()) + if(this->IsImported()) { return this->Target->ImportedGetFullPath(config, implib); } @@ -2661,9 +3238,9 @@ std::string cmGeneratorTarget::NormalGetFullPath(const std::string& config, bool implib, bool realname) const { - std::string fpath = this->Target->GetDirectory(config, implib); + std::string fpath = this->GetDirectory(config, implib); fpath += "/"; - if(this->Target->IsAppBundleOnApple()) + if(this->IsAppBundleOnApple()) { fpath = this->BuildMacContentDirectory(fpath, config, false); fpath += "/"; @@ -2692,14 +3269,14 @@ cmGeneratorTarget::NormalGetRealName(const std::string& config) const // This should not be called for imported targets. // TODO: Split cmTarget into a class hierarchy to get compile-time // enforcement of the limited imported target API. - if(this->Target->IsImported()) + if(this->IsImported()) { std::string msg = "NormalGetRealName called on imported target: "; msg += this->GetName(); this->LocalGenerator->IssueMessage(cmake::INTERNAL_ERROR, msg); } - if(this->GetType() == cmTarget::EXECUTABLE) + if(this->GetType() == cmState::EXECUTABLE) { // Compute the real name that will be built. std::string name; @@ -2734,7 +3311,7 @@ void cmGeneratorTarget::GetLibraryNames(std::string& name, // This should not be called for imported targets. // TODO: Split cmTarget into a class hierarchy to get compile-time // enforcement of the limited imported target API. - if(this->Target->IsImported()) + if(this->IsImported()) { std::string msg = "GetLibraryNames called on imported target: "; msg += this->GetName(); @@ -2747,7 +3324,8 @@ void cmGeneratorTarget::GetLibraryNames(std::string& name, const char* version = this->GetProperty("VERSION"); const char* soversion = this->GetProperty("SOVERSION"); if(!this->HasSOName(config) || - this->Target->IsFrameworkOnApple()) + this->Makefile->IsOn("CMAKE_PLATFORM_NO_VERSIONED_SONAME") || + this->IsFrameworkOnApple()) { // Versioning is supported only for shared libraries and modules, // and then only when the platform supports an soname flag. @@ -2775,13 +3353,13 @@ void cmGeneratorTarget::GetLibraryNames(std::string& name, // The library name. name = prefix+base+suffix; - if(this->Target->IsFrameworkOnApple()) + if(this->IsFrameworkOnApple()) { realName = prefix; if(!this->Makefile->PlatformIsAppleIos()) { realName += "Versions/"; - realName += this->Target->GetFrameworkVersion(); + realName += this->GetFrameworkVersion(); realName += "/"; } realName += base; @@ -2790,17 +3368,17 @@ void cmGeneratorTarget::GetLibraryNames(std::string& name, else { // The library's soname. - this->Target->ComputeVersionedName(soName, prefix, base, suffix, + this->ComputeVersionedName(soName, prefix, base, suffix, name, soversion); // The library's real name on disk. - this->Target->ComputeVersionedName(realName, prefix, base, suffix, + this->ComputeVersionedName(realName, prefix, base, suffix, name, version); } // The import library name. - if(this->GetType() == cmTarget::SHARED_LIBRARY || - this->GetType() == cmTarget::MODULE_LIBRARY) + if(this->GetType() == cmState::SHARED_LIBRARY || + this->GetType() == cmState::MODULE_LIBRARY) { impName = this->GetFullNameInternal(config, true); } @@ -2823,7 +3401,7 @@ void cmGeneratorTarget::GetExecutableNames(std::string& name, // This should not be called for imported targets. // TODO: Split cmTarget into a class hierarchy to get compile-time // enforcement of the limited imported target API. - if(this->Target->IsImported()) + if(this->IsImported()) { std::string msg = "GetExecutableNames called on imported target: "; @@ -2838,7 +3416,7 @@ void cmGeneratorTarget::GetExecutableNames(std::string& name, #else // Check for executable version properties. const char* version = this->GetProperty("VERSION"); - if(this->GetType() != cmTarget::EXECUTABLE || this->Makefile->IsOn("XCODE")) + if(this->GetType() != cmState::EXECUTABLE || this->Makefile->IsOn("XCODE")) { version = 0; } @@ -2887,6 +3465,24 @@ std::string cmGeneratorTarget::GetFullNameInternal(const std::string& config, } //---------------------------------------------------------------------------- +const char* +cmGeneratorTarget::ImportedGetLocation(const std::string& config) const +{ + static std::string location; + assert(this->IsImported()); + location = this->Target->ImportedGetFullPath(config, false); + return location.c_str(); +} + +//---------------------------------------------------------------------------- +std::string cmGeneratorTarget::GetFullNameImported(const std::string& config, + bool implib) const +{ + return cmSystemTools::GetFilenameName( + this->Target->ImportedGetFullPath(config, implib)); +} + +//---------------------------------------------------------------------------- void cmGeneratorTarget::GetFullNameInternal(const std::string& config, bool implib, std::string& outPrefix, @@ -2894,10 +3490,10 @@ void cmGeneratorTarget::GetFullNameInternal(const std::string& config, std::string& outSuffix) const { // Use just the target name for non-main target types. - if(this->GetType() != cmTarget::STATIC_LIBRARY && - this->GetType() != cmTarget::SHARED_LIBRARY && - this->GetType() != cmTarget::MODULE_LIBRARY && - this->GetType() != cmTarget::EXECUTABLE) + if(this->GetType() != cmState::STATIC_LIBRARY && + this->GetType() != cmState::SHARED_LIBRARY && + this->GetType() != cmState::MODULE_LIBRARY && + this->GetType() != cmState::EXECUTABLE) { outPrefix = ""; outBase = this->GetName(); @@ -2918,9 +3514,9 @@ void cmGeneratorTarget::GetFullNameInternal(const std::string& config, // The implib option is only allowed for shared libraries, module // libraries, and executables. - if(this->GetType() != cmTarget::SHARED_LIBRARY && - this->GetType() != cmTarget::MODULE_LIBRARY && - this->GetType() != cmTarget::EXECUTABLE) + if(this->GetType() != cmState::SHARED_LIBRARY && + this->GetType() != cmState::MODULE_LIBRARY && + this->GetType() != cmState::EXECUTABLE) { implib = false; } @@ -2940,8 +3536,7 @@ void cmGeneratorTarget::GetFullNameInternal(const std::string& config, configPostfix = this->GetProperty(configProp); // Mac application bundles and frameworks have no postfix. if(configPostfix && - (this->Target->IsAppBundleOnApple() - || this->Target->IsFrameworkOnApple())) + (this->IsAppBundleOnApple() || this->IsFrameworkOnApple())) { configPostfix = 0; } @@ -2978,7 +3573,7 @@ void cmGeneratorTarget::GetFullNameInternal(const std::string& config, // frameworks have directory prefix but no suffix std::string fw_prefix; - if(this->Target->IsFrameworkOnApple()) + if(this->IsFrameworkOnApple()) { fw_prefix = this->GetOutputName(config, false); fw_prefix += ".framework/"; @@ -2986,7 +3581,7 @@ void cmGeneratorTarget::GetFullNameInternal(const std::string& config, targetSuffix = 0; } - if(this->Target->IsCFBundleOnApple()) + if(this->IsCFBundleOnApple()) { fw_prefix = this->GetCFBundleDirectory(config, false); fw_prefix += "/"; @@ -3006,7 +3601,7 @@ void cmGeneratorTarget::GetFullNameInternal(const std::string& config, // Name shared libraries with their version number on some platforms. if(const char* soversion = this->GetProperty("SOVERSION")) { - if(this->GetType() == cmTarget::SHARED_LIBRARY && !implib && + if(this->GetType() == cmState::SHARED_LIBRARY && !implib && this->Makefile->IsOn("CMAKE_SHARED_LIBRARY_NAME_WITH_VERSION")) { outBase += "-"; @@ -3058,14 +3653,14 @@ std::string cmGeneratorTarget::GetPDBName(const std::string& config) const return prefix+base+".pdb"; } -bool cmStrictTargetComparison::operator()(cmTarget const* t1, - cmTarget const* t2) const +bool cmGeneratorTarget::StrictTargetComparison::operator()( + cmGeneratorTarget const* t1, cmGeneratorTarget const* t2) const { int nameResult = strcmp(t1->GetName().c_str(), t2->GetName().c_str()); if (nameResult == 0) { - return strcmp(t1->GetMakefile()->GetCurrentBinaryDirectory(), - t2->GetMakefile()->GetCurrentBinaryDirectory()) < 0; + return strcmp(t1->GetLocalGenerator()->GetCurrentBinaryDirectory(), + t2->GetLocalGenerator()->GetCurrentBinaryDirectory()) < 0; } return nameResult < 0; } @@ -3112,7 +3707,7 @@ void cmGeneratorTarget::ConstructSourceFileFlags() const this->SourceFileFlagsConstructed = true; // Process public headers to mark the source files. - if(const char* files = this->Target->GetProperty("PUBLIC_HEADER")) + if(const char* files = this->GetProperty("PUBLIC_HEADER")) { std::vector<std::string> relFiles; cmSystemTools::ExpandListArgument(files, relFiles); @@ -3130,7 +3725,7 @@ void cmGeneratorTarget::ConstructSourceFileFlags() const // Process private headers after public headers so that they take // precedence if a file is listed in both. - if(const char* files = this->Target->GetProperty("PRIVATE_HEADER")) + if(const char* files = this->GetProperty("PRIVATE_HEADER")) { std::vector<std::string> relFiles; cmSystemTools::ExpandListArgument(files, relFiles); @@ -3147,7 +3742,7 @@ void cmGeneratorTarget::ConstructSourceFileFlags() const } // Mark sources listed as resources. - if(const char* files = this->Target->GetProperty("RESOURCE")) + if(const char* files = this->GetProperty("RESOURCE")) { std::vector<std::string> relFiles; cmSystemTools::ExpandListArgument(files, relFiles); @@ -3175,10 +3770,10 @@ cmGeneratorTarget::GetCompatibleInterfaces(std::string const& config) const compat.Done = true; compat.PropsBool.insert("POSITION_INDEPENDENT_CODE"); compat.PropsString.insert("AUTOUIC_OPTIONS"); - std::vector<cmTarget const*> const& deps = + std::vector<cmGeneratorTarget const*> const& deps = this->GetLinkImplementationClosure(config); - for(std::vector<cmTarget const*>::const_iterator li = deps.begin(); - li != deps.end(); ++li) + for(std::vector<cmGeneratorTarget const*>::const_iterator li = + deps.begin(); li != deps.end(); ++li) { #define CM_READ_COMPATIBLE_INTERFACE(X, x) \ if(const char* prop = (*li)->GetProperty("COMPATIBLE_INTERFACE_" #X)) \ @@ -3201,8 +3796,8 @@ cmGeneratorTarget::GetCompatibleInterfaces(std::string const& config) const bool cmGeneratorTarget::IsLinkInterfaceDependentBoolProperty( const std::string &p, const std::string& config) const { - if (this->Target->GetType() == cmTarget::OBJECT_LIBRARY - || this->Target->GetType() == cmTarget::INTERFACE_LIBRARY) + if (this->GetType() == cmState::OBJECT_LIBRARY + || this->GetType() == cmState::INTERFACE_LIBRARY) { return false; } @@ -3213,8 +3808,8 @@ bool cmGeneratorTarget::IsLinkInterfaceDependentBoolProperty( bool cmGeneratorTarget::IsLinkInterfaceDependentStringProperty( const std::string &p, const std::string& config) const { - if (this->Target->GetType() == cmTarget::OBJECT_LIBRARY - || this->Target->GetType() == cmTarget::INTERFACE_LIBRARY) + if (this->GetType() == cmState::OBJECT_LIBRARY + || this->GetType() == cmState::INTERFACE_LIBRARY) { return false; } @@ -3225,8 +3820,8 @@ bool cmGeneratorTarget::IsLinkInterfaceDependentStringProperty( bool cmGeneratorTarget::IsLinkInterfaceDependentNumberMinProperty( const std::string &p, const std::string& config) const { - if (this->Target->GetType() == cmTarget::OBJECT_LIBRARY - || this->Target->GetType() == cmTarget::INTERFACE_LIBRARY) + if (this->GetType() == cmState::OBJECT_LIBRARY + || this->GetType() == cmState::INTERFACE_LIBRARY) { return false; } @@ -3237,8 +3832,8 @@ bool cmGeneratorTarget::IsLinkInterfaceDependentNumberMinProperty( bool cmGeneratorTarget::IsLinkInterfaceDependentNumberMaxProperty( const std::string &p, const std::string& config) const { - if (this->Target->GetType() == cmTarget::OBJECT_LIBRARY - || this->Target->GetType() == cmTarget::INTERFACE_LIBRARY) + if (this->GetType() == cmState::OBJECT_LIBRARY + || this->GetType() == cmState::INTERFACE_LIBRARY) { return false; } @@ -3295,7 +3890,7 @@ const char * getLinkInterfaceDependentProperty(cmGeneratorTarget const* tgt, //---------------------------------------------------------------------------- template<typename PropertyType> void checkPropertyConsistency(cmGeneratorTarget const* depender, - cmTarget const* dependee, + cmGeneratorTarget const* dependee, const std::string& propName, std::set<std::string> &emitted, const std::string& config, @@ -3311,7 +3906,7 @@ void checkPropertyConsistency(cmGeneratorTarget const* depender, std::vector<std::string> props; cmSystemTools::ExpandListArgument(prop, props); std::string pdir = - dependee->GetMakefile()->GetRequiredDefinition("CMAKE_ROOT"); + dependee->Target->GetMakefile()->GetRequiredDefinition("CMAKE_ROOT"); pdir += "/Help/prop_tgt/"; for(std::vector<std::string>::iterator pi = props.begin(); @@ -3524,18 +4119,20 @@ std::string compatibilityAgree(CompatibleType t, bool dominant) //---------------------------------------------------------------------------- template<typename PropertyType> -PropertyType getTypedProperty(cmTarget const* tgt, const std::string& prop); +PropertyType getTypedProperty(cmGeneratorTarget const* tgt, + const std::string& prop); //---------------------------------------------------------------------------- template<> -bool getTypedProperty<bool>(cmTarget const* tgt, const std::string& prop) +bool getTypedProperty<bool>(cmGeneratorTarget const* tgt, + const std::string& prop) { return tgt->GetPropertyAsBool(prop); } //---------------------------------------------------------------------------- template<> -const char *getTypedProperty<const char *>(cmTarget const* tgt, +const char *getTypedProperty<const char *>(cmGeneratorTarget const* tgt, const std::string& prop) { return tgt->GetProperty(prop); @@ -3665,16 +4262,18 @@ PropertyType checkInterfacePropertyCompatibility(cmGeneratorTarget const* tgt, CompatibleType t, PropertyType *) { - PropertyType propContent = getTypedProperty<PropertyType>(tgt->Target, p); - const bool explicitlySet = tgt->Target->GetProperties() - .find(p) - != tgt->Target->GetProperties().end(); + PropertyType propContent = getTypedProperty<PropertyType>(tgt, p); + std::vector<std::string> headPropKeys = tgt->GetPropertyKeys(); + const bool explicitlySet = + std::find(headPropKeys.begin(), headPropKeys.end(), + p) != headPropKeys.end(); + const bool impliedByUse = - tgt->Target->IsNullImpliedByLinkLibraries(p); + tgt->IsNullImpliedByLinkLibraries(p); assert((impliedByUse ^ explicitlySet) || (!impliedByUse && !explicitlySet)); - std::vector<cmTarget const*> const& deps = + std::vector<cmGeneratorTarget const*> const& deps = tgt->GetLinkImplementationClosure(config); if(deps.empty()) @@ -3701,7 +4300,7 @@ PropertyType checkInterfacePropertyCompatibility(cmGeneratorTarget const* tgt, } std::string interfaceProperty = "INTERFACE_" + p; - for(std::vector<cmTarget const*>::const_iterator li = + for(std::vector<cmGeneratorTarget const*>::const_iterator li = deps.begin(); li != deps.end(); ++li) { @@ -3711,11 +4310,13 @@ PropertyType checkInterfacePropertyCompatibility(cmGeneratorTarget const* tgt, // target itself has a POSITION_INDEPENDENT_CODE which disagrees // with a dependency. - cmTarget const* theTarget = *li; + cmGeneratorTarget const* theTarget = *li; + + std::vector<std::string> propKeys = theTarget->GetPropertyKeys(); - const bool ifaceIsSet = theTarget->GetProperties() - .find(interfaceProperty) - != theTarget->GetProperties().end(); + const bool ifaceIsSet = + std::find(propKeys.begin(), propKeys.end(), + interfaceProperty) != propKeys.end(); PropertyType ifacePropContent = getTypedProperty<PropertyType>(theTarget, interfaceProperty); @@ -3919,6 +4520,93 @@ cmGeneratorTarget::GetLinkInformation(const std::string& config) const } //---------------------------------------------------------------------------- +void cmGeneratorTarget::GetTargetVersion(int& major, int& minor) const +{ + int patch; + this->GetTargetVersion(false, major, minor, patch); +} + +//---------------------------------------------------------------------------- +void cmGeneratorTarget::GetTargetVersion(bool soversion, + int& major, int& minor, int& patch) const +{ + // Set the default values. + major = 0; + minor = 0; + patch = 0; + + assert(this->GetType() != cmState::INTERFACE_LIBRARY); + + // Look for a VERSION or SOVERSION property. + const char* prop = soversion? "SOVERSION" : "VERSION"; + if(const char* version = this->GetProperty(prop)) + { + // Try to parse the version number and store the results that were + // successfully parsed. + int parsed_major; + int parsed_minor; + int parsed_patch; + switch(sscanf(version, "%d.%d.%d", + &parsed_major, &parsed_minor, &parsed_patch)) + { + case 3: patch = parsed_patch; // no break! + case 2: minor = parsed_minor; // no break! + case 1: major = parsed_major; // no break! + default: break; + } + } +} + +//---------------------------------------------------------------------------- +std::string cmGeneratorTarget::GetFrameworkVersion() const +{ + assert(this->GetType() != cmState::INTERFACE_LIBRARY); + + if(const char* fversion = this->GetProperty("FRAMEWORK_VERSION")) + { + return fversion; + } + else if(const char* tversion = this->GetProperty("VERSION")) + { + return tversion; + } + else + { + return "A"; + } +} + +//---------------------------------------------------------------------------- +void cmGeneratorTarget::ComputeVersionedName(std::string& vName, + std::string const& prefix, + std::string const& base, + std::string const& suffix, + std::string const& name, + const char* version) const +{ + vName = this->Makefile->IsOn("APPLE") ? (prefix+base) : name; + if(version) + { + vName += "."; + vName += version; + } + vName += this->Makefile->IsOn("APPLE") ? suffix : std::string(); +} + +std::vector<std::string> cmGeneratorTarget::GetPropertyKeys() const +{ + cmPropertyMap propsObject = this->Target->GetProperties(); + std::vector<std::string> props; + props.reserve(propsObject.size()); + for (cmPropertyMap::const_iterator it = propsObject.begin(); + it != propsObject.end(); ++it) + { + props.push_back(it->first); + } + return props; +} + +//---------------------------------------------------------------------------- void cmGeneratorTarget::ReportPropertyOrigin(const std::string &p, const std::string &result, @@ -3955,7 +4643,7 @@ cmGeneratorTarget::ReportPropertyOrigin(const std::string &p, areport += result; areport += "\"):\n" + report; - this->Makefile->GetCMakeInstance()->IssueMessage(cmake::LOG, areport); + this->LocalGenerator->GetCMakeInstance()->IssueMessage(cmake::LOG, areport); } //---------------------------------------------------------------------------- @@ -3965,12 +4653,12 @@ void cmGeneratorTarget::LookupLinkItems(std::vector<std::string> const& names, for(std::vector<std::string>::const_iterator i = names.begin(); i != names.end(); ++i) { - std::string name = this->Target->CheckCMP0004(*i); + std::string name = this->CheckCMP0004(*i); if(name == this->GetName() || name.empty()) { continue; } - items.push_back(cmLinkItem(name, this->Target->FindTargetToLink(name))); + items.push_back(cmLinkItem(name, this->FindTargetToLink(name))); } } @@ -3978,7 +4666,7 @@ void cmGeneratorTarget::LookupLinkItems(std::vector<std::string> const& names, void cmGeneratorTarget::ExpandLinkItems(std::string const& prop, std::string const& value, std::string const& config, - cmTarget const* headTarget, + cmGeneratorTarget const* headTarget, bool usage_requirements_only, std::vector<cmLinkItem>& items, bool& hadHeadSensitiveCondition) const @@ -3994,11 +4682,11 @@ void cmGeneratorTarget::ExpandLinkItems(std::string const& prop, std::vector<std::string> libs; cmsys::auto_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(value); cmSystemTools::ExpandListArgument(cge->Evaluate( - this->Makefile, + this->LocalGenerator, config, false, headTarget, - this->Target, &dagChecker), libs); + this, &dagChecker), libs); this->LookupLinkItems(libs, items); hadHeadSensitiveCondition = cge->GetHadHeadSensitiveCondition(); } @@ -4006,7 +4694,7 @@ void cmGeneratorTarget::ExpandLinkItems(std::string const& prop, //---------------------------------------------------------------------------- cmLinkInterface const* cmGeneratorTarget::GetLinkInterface(const std::string& config, - cmTarget const* head) const + cmGeneratorTarget const* head) const { // Imported targets have their own link interface. if(this->IsImported()) @@ -4016,8 +4704,8 @@ cmGeneratorTarget::GetLinkInterface(const std::string& config, // Link interfaces are not supported for executables that do not // export symbols. - if(this->GetType() == cmTarget::EXECUTABLE && - !this->Target->IsExecutableWithExports()) + if(this->GetType() == cmState::EXECUTABLE && + !this->IsExecutableWithExports()) { return 0; } @@ -4055,13 +4743,13 @@ cmGeneratorTarget::GetLinkInterface(const std::string& config, //---------------------------------------------------------------------------- void cmGeneratorTarget::ComputeLinkInterface(const std::string& config, cmOptionalLinkInterface &iface, - cmTarget const* headTarget) const + cmGeneratorTarget const* headTarget) const { if(iface.ExplicitLibraries) { - if(this->GetType() == cmTarget::SHARED_LIBRARY - || this->GetType() == cmTarget::STATIC_LIBRARY - || this->GetType() == cmTarget::INTERFACE_LIBRARY) + if(this->GetType() == cmState::SHARED_LIBRARY + || this->GetType() == cmState::STATIC_LIBRARY + || this->GetType() == cmState::INTERFACE_LIBRARY) { // Shared libraries may have runtime implementation dependencies // on other shared libraries that are not in the interface. @@ -4071,7 +4759,7 @@ void cmGeneratorTarget::ComputeLinkInterface(const std::string& config, { emitted.insert(*li); } - if (this->GetType() != cmTarget::INTERFACE_LIBRARY) + if (this->GetType() != cmState::INTERFACE_LIBRARY) { cmLinkImplementation const* impl = this->GetLinkImplementation(config); @@ -4083,7 +4771,7 @@ void cmGeneratorTarget::ComputeLinkInterface(const std::string& config, if(li->Target) { // This is a runtime dependency on another shared library. - if(li->Target->GetType() == cmTarget::SHARED_LIBRARY) + if(li->Target->GetType() == cmState::SHARED_LIBRARY) { iface.SharedDeps.push_back(*li); } @@ -4100,18 +4788,18 @@ void cmGeneratorTarget::ComputeLinkInterface(const std::string& config, } } } - else if (this->Target->GetPolicyStatusCMP0022() == cmPolicies::WARN - || this->Target->GetPolicyStatusCMP0022() == cmPolicies::OLD) + else if (this->GetPolicyStatusCMP0022() == cmPolicies::WARN + || this->GetPolicyStatusCMP0022() == cmPolicies::OLD) { // The link implementation is the default link interface. cmLinkImplementationLibraries const* - impl = this->Target->GetLinkImplementationLibrariesInternal(config, - headTarget); + impl = this->GetLinkImplementationLibrariesInternal(config, + headTarget); iface.ImplementationIsInterface = true; iface.WrongConfigLibraries = impl->WrongConfigLibraries; } - if(this->Target->LinkLanguagePropagatesToDependents()) + if(this->LinkLanguagePropagatesToDependents()) { // Targets using this archive need its language runtime libraries. if(cmLinkImplementation const* impl = @@ -4121,7 +4809,7 @@ void cmGeneratorTarget::ComputeLinkInterface(const std::string& config, } } - if(this->GetType() == cmTarget::STATIC_LIBRARY) + if(this->GetType() == cmState::STATIC_LIBRARY) { // Construct the property name suffix for this configuration. std::string suffix = "_"; @@ -4153,7 +4841,7 @@ void cmGeneratorTarget::ComputeLinkInterface(const std::string& config, //---------------------------------------------------------------------------- const cmLinkInterfaceLibraries * cmGeneratorTarget::GetLinkInterfaceLibraries(const std::string& config, - cmTarget const* head, + cmGeneratorTarget const* head, bool usage_requirements_only) const { // Imported targets have their own link interface. @@ -4165,8 +4853,8 @@ cmGeneratorTarget::GetLinkInterfaceLibraries(const std::string& config, // Link interfaces are not supported for executables that do not // export symbols. - if(this->GetType() == cmTarget::EXECUTABLE && - !this->Target->IsExecutableWithExports()) + if(this->GetType() == cmState::EXECUTABLE && + !this->IsExecutableWithExports()) { return 0; } @@ -4197,11 +4885,261 @@ cmGeneratorTarget::GetLinkInterfaceLibraries(const std::string& config, } //---------------------------------------------------------------------------- +std::string cmGeneratorTarget::GetDirectory(const std::string& config, + bool implib) const +{ + if (this->IsImported()) + { + // Return the directory from which the target is imported. + return + cmSystemTools::GetFilenamePath( + this->Target->ImportedGetFullPath(config, implib)); + } + else if(OutputInfo const* info = this->GetOutputInfo(config)) + { + // Return the directory in which the target will be built. + return implib? info->ImpDir : info->OutDir; + } + return ""; +} + +//---------------------------------------------------------------------------- +bool cmGeneratorTarget::UsesDefaultOutputDir(const std::string& config, + bool implib) const +{ + std::string dir; + return this->ComputeOutputDir(config, implib, dir); +} + +//---------------------------------------------------------------------------- +cmGeneratorTarget::OutputInfo const* cmGeneratorTarget::GetOutputInfo( + const std::string& config) const +{ + // There is no output information for imported targets. + if(this->IsImported()) + { + return 0; + } + + // Only libraries and executables have well-defined output files. + if(!this->HaveWellDefinedOutputFiles()) + { + std::string msg = "cmGeneratorTarget::GetOutputInfo called for "; + msg += this->GetName(); + msg += " which has type "; + msg += cmState::GetTargetTypeName(this->GetType()); + this->LocalGenerator->IssueMessage(cmake::INTERNAL_ERROR, msg); + return 0; + } + + // Lookup/compute/cache the output information for this configuration. + std::string config_upper; + if(!config.empty()) + { + config_upper = cmSystemTools::UpperCase(config); + } + OutputInfoMapType::iterator i = + this->OutputInfoMap.find(config_upper); + if(i == this->OutputInfoMap.end()) + { + // Add empty info in map to detect potential recursion. + OutputInfo info; + OutputInfoMapType::value_type entry(config_upper, info); + i = this->OutputInfoMap.insert(entry).first; + + // Compute output directories. + this->ComputeOutputDir(config, false, info.OutDir); + this->ComputeOutputDir(config, true, info.ImpDir); + if(!this->ComputePDBOutputDir("PDB", config, info.PdbDir)) + { + info.PdbDir = info.OutDir; + } + + // Now update the previously-prepared map entry. + i->second = info; + } + else if(i->second.empty()) + { + // An empty map entry indicates we have been called recursively + // from the above block. + this->LocalGenerator->GetCMakeInstance()->IssueMessage( + cmake::FATAL_ERROR, + "Target '" + this->GetName() + "' OUTPUT_DIRECTORY depends on itself.", + this->GetBacktrace()); + return 0; + } + return &i->second; +} + +//---------------------------------------------------------------------------- +bool cmGeneratorTarget::ComputeOutputDir(const std::string& config, + bool implib, std::string& out) const +{ + bool usesDefaultOutputDir = false; + std::string conf = config; + + // Look for a target property defining the target output directory + // based on the target type. + std::string targetTypeName = this->GetOutputTargetType(implib); + const char* propertyName = 0; + std::string propertyNameStr = targetTypeName; + if(!propertyNameStr.empty()) + { + propertyNameStr += "_OUTPUT_DIRECTORY"; + propertyName = propertyNameStr.c_str(); + } + + // Check for a per-configuration output directory target property. + std::string configUpper = cmSystemTools::UpperCase(conf); + const char* configProp = 0; + std::string configPropStr = targetTypeName; + if(!configPropStr.empty()) + { + configPropStr += "_OUTPUT_DIRECTORY_"; + configPropStr += configUpper; + configProp = configPropStr.c_str(); + } + + // Select an output directory. + if(const char* config_outdir = this->GetProperty(configProp)) + { + // Use the user-specified per-configuration output directory. + cmGeneratorExpression ge; + cmsys::auto_ptr<cmCompiledGeneratorExpression> cge = + ge.Parse(config_outdir); + out = cge->Evaluate(this->LocalGenerator, config); + + // Skip per-configuration subdirectory. + conf = ""; + } + else if(const char* outdir = this->GetProperty(propertyName)) + { + // Use the user-specified output directory. + cmGeneratorExpression ge; + cmsys::auto_ptr<cmCompiledGeneratorExpression> cge = + ge.Parse(outdir); + out = cge->Evaluate(this->LocalGenerator, config); + + // Skip per-configuration subdirectory if the value contained a + // generator expression. + if (out != outdir) + { + conf = ""; + } + } + else if(this->GetType() == cmState::EXECUTABLE) + { + // Lookup the output path for executables. + out = this->Makefile->GetSafeDefinition("EXECUTABLE_OUTPUT_PATH"); + } + else if(this->GetType() == cmState::STATIC_LIBRARY || + this->GetType() == cmState::SHARED_LIBRARY || + this->GetType() == cmState::MODULE_LIBRARY) + { + // Lookup the output path for libraries. + out = this->Makefile->GetSafeDefinition("LIBRARY_OUTPUT_PATH"); + } + if(out.empty()) + { + // Default to the current output directory. + usesDefaultOutputDir = true; + out = "."; + } + + // Convert the output path to a full path in case it is + // specified as a relative path. Treat a relative path as + // relative to the current output directory for this makefile. + out = (cmSystemTools::CollapseFullPath + (out, this->LocalGenerator->GetCurrentBinaryDirectory())); + + // The generator may add the configuration's subdirectory. + if(!conf.empty()) + { + bool iosPlatform = this->Makefile->PlatformIsAppleIos(); + std::string suffix = + usesDefaultOutputDir && iosPlatform ? "${EFFECTIVE_PLATFORM_NAME}" : ""; + this->LocalGenerator->GetGlobalGenerator()-> + AppendDirectoryForConfig("/", conf, suffix, out); + } + + return usesDefaultOutputDir; +} + +//---------------------------------------------------------------------------- +bool cmGeneratorTarget::ComputePDBOutputDir(const std::string& kind, + const std::string& config, + std::string& out) const +{ + // Look for a target property defining the target output directory + // based on the target type. + const char* propertyName = 0; + std::string propertyNameStr = kind; + if(!propertyNameStr.empty()) + { + propertyNameStr += "_OUTPUT_DIRECTORY"; + propertyName = propertyNameStr.c_str(); + } + std::string conf = config; + + // Check for a per-configuration output directory target property. + std::string configUpper = cmSystemTools::UpperCase(conf); + const char* configProp = 0; + std::string configPropStr = kind; + if(!configPropStr.empty()) + { + configPropStr += "_OUTPUT_DIRECTORY_"; + configPropStr += configUpper; + configProp = configPropStr.c_str(); + } + + // Select an output directory. + if(const char* config_outdir = this->GetProperty(configProp)) + { + // Use the user-specified per-configuration output directory. + out = config_outdir; + + // Skip per-configuration subdirectory. + conf = ""; + } + else if(const char* outdir = this->GetProperty(propertyName)) + { + // Use the user-specified output directory. + out = outdir; + } + if(out.empty()) + { + return false; + } + + // Convert the output path to a full path in case it is + // specified as a relative path. Treat a relative path as + // relative to the current output directory for this makefile. + out = (cmSystemTools::CollapseFullPath + (out, this->LocalGenerator->GetCurrentBinaryDirectory())); + + // The generator may add the configuration's subdirectory. + if(!conf.empty()) + { + this->LocalGenerator->GetGlobalGenerator()-> + AppendDirectoryForConfig("/", conf, "", out); + } + return true; +} + +//---------------------------------------------------------------------------- +bool cmGeneratorTarget::HaveInstallTreeRPATH() const +{ + const char* install_rpath = this->GetProperty("INSTALL_RPATH"); + return (install_rpath && *install_rpath) && + !this->Makefile->IsOn("CMAKE_SKIP_INSTALL_RPATH"); +} + +//---------------------------------------------------------------------------- void cmGeneratorTarget::ComputeLinkInterfaceLibraries( const std::string& config, cmOptionalLinkInterface& iface, - cmTarget const* headTarget, + cmGeneratorTarget const* headTarget, bool usage_requirements_only) const { // Construct the property name suffix for this configuration. @@ -4219,15 +5157,15 @@ cmGeneratorTarget::ComputeLinkInterfaceLibraries( // libraries and executables that export symbols. const char* explicitLibraries = 0; std::string linkIfaceProp; - if(this->Target->GetPolicyStatusCMP0022() != cmPolicies::OLD && - this->Target->GetPolicyStatusCMP0022() != cmPolicies::WARN) + if(this->GetPolicyStatusCMP0022() != cmPolicies::OLD && + this->GetPolicyStatusCMP0022() != cmPolicies::WARN) { // CMP0022 NEW behavior is to use INTERFACE_LINK_LIBRARIES. linkIfaceProp = "INTERFACE_LINK_LIBRARIES"; explicitLibraries = this->GetProperty(linkIfaceProp); } - else if(this->GetType() == cmTarget::SHARED_LIBRARY || - this->Target->IsExecutableWithExports()) + else if(this->GetType() == cmState::SHARED_LIBRARY || + this->IsExecutableWithExports()) { // CMP0022 OLD behavior is to use LINK_INTERFACE_LIBRARIES if set on a // shared lib or executable. @@ -4246,7 +5184,7 @@ cmGeneratorTarget::ComputeLinkInterfaceLibraries( } if(explicitLibraries && - this->Target->GetPolicyStatusCMP0022() == cmPolicies::WARN && + this->GetPolicyStatusCMP0022() == cmPolicies::WARN && !this->PolicyWarnedCMP0022) { // Compare the explicitly set old link interface properties to the @@ -4274,8 +5212,8 @@ cmGeneratorTarget::ComputeLinkInterfaceLibraries( // There is no implicit link interface for executables or modules // so if none was explicitly set then there is no link interface. if(!explicitLibraries && - (this->GetType() == cmTarget::EXECUTABLE || - (this->GetType() == cmTarget::MODULE_LIBRARY))) + (this->GetType() == cmState::EXECUTABLE || + (this->GetType() == cmState::MODULE_LIBRARY))) { return; } @@ -4291,8 +5229,8 @@ cmGeneratorTarget::ComputeLinkInterfaceLibraries( iface.Libraries, iface.HadHeadSensitiveCondition); } - else if (this->Target->GetPolicyStatusCMP0022() == cmPolicies::WARN - || this->Target->GetPolicyStatusCMP0022() == cmPolicies::OLD) + else if (this->GetPolicyStatusCMP0022() == cmPolicies::WARN + || this->GetPolicyStatusCMP0022() == cmPolicies::OLD) // If CMP0022 is NEW then the plain tll signature sets the // INTERFACE_LINK_LIBRARIES, so if we get here then the project // cleared the property explicitly and we should not fall back @@ -4300,11 +5238,10 @@ cmGeneratorTarget::ComputeLinkInterfaceLibraries( { // The link implementation is the default link interface. cmLinkImplementationLibraries const* impl = - this->Target->GetLinkImplementationLibrariesInternal(config, - headTarget); + this->GetLinkImplementationLibrariesInternal(config, headTarget); iface.Libraries.insert(iface.Libraries.end(), impl->Libraries.begin(), impl->Libraries.end()); - if(this->Target->GetPolicyStatusCMP0022() == cmPolicies::WARN && + if(this->GetPolicyStatusCMP0022() == cmPolicies::WARN && !this->PolicyWarnedCMP0022 && !usage_requirements_only) { // Compare the link implementation fallback link interface to the @@ -4315,8 +5252,9 @@ cmGeneratorTarget::ComputeLinkInterfaceLibraries( { bool hadHeadSensitiveConditionDummy = false; this->ExpandLinkItems(newProp, newExplicitLibraries, config, - headTarget, usage_requirements_only, - ifaceLibs, hadHeadSensitiveConditionDummy); + headTarget, + usage_requirements_only, + ifaceLibs, hadHeadSensitiveConditionDummy); } if (ifaceLibs != iface.Libraries) { @@ -4350,10 +5288,10 @@ cmGeneratorTarget::ComputeLinkInterfaceLibraries( //---------------------------------------------------------------------------- const cmLinkInterface * cmGeneratorTarget::GetImportLinkInterface(const std::string& config, - cmTarget const* headTarget, + cmGeneratorTarget const* headTarget, bool usage_requirements_only) const { - cmTarget::ImportInfo const* info = this->Target->GetImportInfo(config); + cmGeneratorTarget::ImportInfo const* info = this->GetImportInfo(config); if(!info) { return 0; @@ -4391,6 +5329,223 @@ cmGeneratorTarget::GetImportLinkInterface(const std::string& config, return &iface; } +//---------------------------------------------------------------------------- +cmGeneratorTarget::ImportInfo const* +cmGeneratorTarget::GetImportInfo(const std::string& config) const +{ + // There is no imported information for non-imported targets. + if(!this->IsImported()) + { + return 0; + } + + // Lookup/compute/cache the import information for this + // configuration. + std::string config_upper; + if(!config.empty()) + { + config_upper = cmSystemTools::UpperCase(config); + } + else + { + config_upper = "NOCONFIG"; + } + + ImportInfoMapType::const_iterator i = + this->ImportInfoMap.find(config_upper); + if(i == this->ImportInfoMap.end()) + { + ImportInfo info; + this->ComputeImportInfo(config_upper, info); + ImportInfoMapType::value_type entry(config_upper, info); + i = this->ImportInfoMap.insert(entry).first; + } + + if(this->GetType() == cmState::INTERFACE_LIBRARY) + { + return &i->second; + } + // If the location is empty then the target is not available for + // this configuration. + if(i->second.Location.empty() && i->second.ImportLibrary.empty()) + { + return 0; + } + + // Return the import information. + return &i->second; +} + +//---------------------------------------------------------------------------- +void cmGeneratorTarget::ComputeImportInfo(std::string const& desired_config, + ImportInfo& info) const +{ + // This method finds information about an imported target from its + // properties. The "IMPORTED_" namespace is reserved for properties + // defined by the project exporting the target. + + // Initialize members. + info.NoSOName = false; + + const char* loc = 0; + const char* imp = 0; + std::string suffix; + if (!this->Target->GetMappedConfig(desired_config, &loc, &imp, suffix)) + { + return; + } + + // Get the link interface. + { + std::string linkProp = "INTERFACE_LINK_LIBRARIES"; + const char *propertyLibs = this->GetProperty(linkProp); + + if (this->GetType() != cmState::INTERFACE_LIBRARY) + { + if(!propertyLibs) + { + linkProp = "IMPORTED_LINK_INTERFACE_LIBRARIES"; + linkProp += suffix; + propertyLibs = this->GetProperty(linkProp); + } + + if(!propertyLibs) + { + linkProp = "IMPORTED_LINK_INTERFACE_LIBRARIES"; + propertyLibs = this->GetProperty(linkProp); + } + } + if(propertyLibs) + { + info.LibrariesProp = linkProp; + info.Libraries = propertyLibs; + } + } + if(this->GetType() == cmState::INTERFACE_LIBRARY) + { + return; + } + + // A provided configuration has been chosen. Load the + // configuration's properties. + + // Get the location. + if(loc) + { + info.Location = loc; + } + else + { + std::string impProp = "IMPORTED_LOCATION"; + impProp += suffix; + if(const char* config_location = this->GetProperty(impProp)) + { + info.Location = config_location; + } + else if(const char* location = this->GetProperty("IMPORTED_LOCATION")) + { + info.Location = location; + } + } + + // Get the soname. + if(this->GetType() == cmState::SHARED_LIBRARY) + { + std::string soProp = "IMPORTED_SONAME"; + soProp += suffix; + if(const char* config_soname = this->GetProperty(soProp)) + { + info.SOName = config_soname; + } + else if(const char* soname = this->GetProperty("IMPORTED_SONAME")) + { + info.SOName = soname; + } + } + + // Get the "no-soname" mark. + if(this->GetType() == cmState::SHARED_LIBRARY) + { + std::string soProp = "IMPORTED_NO_SONAME"; + soProp += suffix; + if(const char* config_no_soname = this->GetProperty(soProp)) + { + info.NoSOName = cmSystemTools::IsOn(config_no_soname); + } + else if(const char* no_soname = this->GetProperty("IMPORTED_NO_SONAME")) + { + info.NoSOName = cmSystemTools::IsOn(no_soname); + } + } + + // Get the import library. + if(imp) + { + info.ImportLibrary = imp; + } + else if(this->GetType() == cmState::SHARED_LIBRARY || + this->IsExecutableWithExports()) + { + std::string impProp = "IMPORTED_IMPLIB"; + impProp += suffix; + if(const char* config_implib = this->GetProperty(impProp)) + { + info.ImportLibrary = config_implib; + } + else if(const char* implib = this->GetProperty("IMPORTED_IMPLIB")) + { + info.ImportLibrary = implib; + } + } + + // Get the link dependencies. + { + std::string linkProp = "IMPORTED_LINK_DEPENDENT_LIBRARIES"; + linkProp += suffix; + if(const char* config_libs = this->GetProperty(linkProp)) + { + info.SharedDeps = config_libs; + } + else if(const char* libs = + this->GetProperty("IMPORTED_LINK_DEPENDENT_LIBRARIES")) + { + info.SharedDeps = libs; + } + } + + // Get the link languages. + if(this->LinkLanguagePropagatesToDependents()) + { + std::string linkProp = "IMPORTED_LINK_INTERFACE_LANGUAGES"; + linkProp += suffix; + if(const char* config_libs = this->GetProperty(linkProp)) + { + info.Languages = config_libs; + } + else if(const char* libs = + this->GetProperty("IMPORTED_LINK_INTERFACE_LANGUAGES")) + { + info.Languages = libs; + } + } + + // Get the cyclic repetition count. + if(this->GetType() == cmState::STATIC_LIBRARY) + { + std::string linkProp = "IMPORTED_LINK_INTERFACE_MULTIPLICITY"; + linkProp += suffix; + if(const char* config_reps = this->GetProperty(linkProp)) + { + sscanf(config_reps, "%u", &info.Multiplicity); + } + else if(const char* reps = + this->GetProperty("IMPORTED_LINK_INTERFACE_MULTIPLICITY")) + { + sscanf(reps, "%u", &info.Multiplicity); + } + } +} + cmHeadToLinkInterfaceMap& cmGeneratorTarget::GetHeadToLinkInterfaceMap(const std::string &config) const { @@ -4411,17 +5566,17 @@ const cmLinkImplementation * cmGeneratorTarget::GetLinkImplementation(const std::string& config) const { // There is no link implementation for imported targets. - if(this->Target->IsImported()) + if(this->IsImported()) { return 0; } - cmOptionalLinkImplementation& impl = this->Target->GetLinkImplMap(config); + std::string CONFIG = cmSystemTools::UpperCase(config); + cmOptionalLinkImplementation& impl = this->LinkImplMap[CONFIG][this]; if(!impl.LibrariesDone) { impl.LibrariesDone = true; - this->Target->ComputeLinkImplementationLibraries(config, impl, - this->Target); + this->ComputeLinkImplementationLibraries(config, impl, this); } if(!impl.LanguagesDone) { @@ -4444,12 +5599,12 @@ bool cmGeneratorTarget::GetConfigCommonSourceFiles( std::vector<std::string>::const_iterator it = configs.begin(); const std::string& firstConfig = *it; - this->Target->GetSourceFiles(files, firstConfig); + this->GetSourceFiles(files, firstConfig); for ( ; it != configs.end(); ++it) { std::vector<cmSourceFile*> configFiles; - this->Target->GetSourceFiles(configFiles, *it); + this->GetSourceFiles(configFiles, *it); if (configFiles != files) { std::string firstConfigFiles; @@ -4489,6 +5644,105 @@ bool cmGeneratorTarget::GetConfigCommonSourceFiles( } //---------------------------------------------------------------------------- +void cmGeneratorTarget::GetObjectLibrariesCMP0026( + std::vector<cmGeneratorTarget*>& objlibs) const +{ + // At configure-time, this method can be called as part of getting the + // LOCATION property or to export() a file to be include()d. However + // there is no cmGeneratorTarget at configure-time, so search the SOURCES + // for TARGET_OBJECTS instead for backwards compatibility with OLD + // behavior of CMP0024 and CMP0026 only. + cmStringRange rng = this->Target->GetSourceEntries(); + for(std::vector<std::string>::const_iterator + i = rng.begin(); i != rng.end(); ++i) + { + std::string const& entry = *i; + + std::vector<std::string> files; + cmSystemTools::ExpandListArgument(entry, files); + for (std::vector<std::string>::const_iterator + li = files.begin(); li != files.end(); ++li) + { + if(cmHasLiteralPrefix(*li, "$<TARGET_OBJECTS:") && + (*li)[li->size() - 1] == '>') + { + std::string objLibName = li->substr(17, li->size()-18); + + if (cmGeneratorExpression::Find(objLibName) != std::string::npos) + { + continue; + } + cmGeneratorTarget *objLib = + this->LocalGenerator->FindGeneratorTargetToUse(objLibName); + if(objLib) + { + objlibs.push_back(objLib); + } + } + } + } +} + +//---------------------------------------------------------------------------- +std::string cmGeneratorTarget::CheckCMP0004(std::string const& item) const +{ + // Strip whitespace off the library names because we used to do this + // in case variables were expanded at generate time. We no longer + // do the expansion but users link to libraries like " ${VAR} ". + std::string lib = item; + std::string::size_type pos = lib.find_first_not_of(" \t\r\n"); + if(pos != lib.npos) + { + lib = lib.substr(pos, lib.npos); + } + pos = lib.find_last_not_of(" \t\r\n"); + if(pos != lib.npos) + { + lib = lib.substr(0, pos+1); + } + if(lib != item) + { + cmake* cm = this->LocalGenerator->GetCMakeInstance(); + switch(this->GetPolicyStatusCMP0004()) + { + case cmPolicies::WARN: + { + std::ostringstream w; + w << cmPolicies::GetPolicyWarning(cmPolicies::CMP0004) << "\n" + << "Target \"" << this->GetName() << "\" links to item \"" + << item << "\" which has leading or trailing whitespace."; + cm->IssueMessage(cmake::AUTHOR_WARNING, w.str(), + this->GetBacktrace()); + } + case cmPolicies::OLD: + break; + case cmPolicies::NEW: + { + std::ostringstream e; + e << "Target \"" << this->GetName() << "\" links to item \"" + << item << "\" which has leading or trailing whitespace. " + << "This is now an error according to policy CMP0004."; + cm->IssueMessage(cmake::FATAL_ERROR, e.str(), + this->GetBacktrace()); + } + break; + case cmPolicies::REQUIRED_IF_USED: + case cmPolicies::REQUIRED_ALWAYS: + { + std::ostringstream e; + e << cmPolicies::GetRequiredPolicyError(cmPolicies::CMP0004) << "\n" + << "Target \"" << this->GetName() << "\" links to item \"" + << item << "\" which has leading or trailing whitespace."; + cm->IssueMessage(cmake::FATAL_ERROR, e.str(), + this->GetBacktrace()); + } + break; + } + } + return lib; +} + +//---------------------------------------------------------------------------- void cmGeneratorTarget::GetLanguages(std::set<std::string>& languages, const std::string& config) const { @@ -4508,14 +5762,13 @@ void cmGeneratorTarget::GetLanguages(std::set<std::string>& languages, std::vector<cmSourceFile const*> externalObjects; if (!this->GlobalGenerator->GetConfigureDoneCMP0026()) { - std::vector<cmTarget*> objectTargets; - this->Target->GetObjectLibrariesCMP0026(objectTargets); + std::vector<cmGeneratorTarget*> objectTargets; + this->GetObjectLibrariesCMP0026(objectTargets); objectLibraries.reserve(objectTargets.size()); - for (std::vector<cmTarget*>::const_iterator it = objectTargets.begin(); - it != objectTargets.end(); ++it) + for (std::vector<cmGeneratorTarget*>::const_iterator it = + objectTargets.begin(); it != objectTargets.end(); ++it) { - objectLibraries.push_back(this->GlobalGenerator - ->GetGeneratorTarget(*it)); + objectLibraries.push_back(*it); } } else @@ -4525,10 +5778,10 @@ void cmGeneratorTarget::GetLanguages(std::set<std::string>& languages, i = externalObjects.begin(); i != externalObjects.end(); ++i) { std::string objLib = (*i)->GetObjectLibrary(); - if (cmTarget* tgt = this->Makefile->FindTargetToUse(objLib)) + if (cmGeneratorTarget* tgt = + this->LocalGenerator->FindGeneratorTargetToUse(objLib)) { - objectLibraries.push_back(this->GlobalGenerator - ->GetGeneratorTarget(tgt)); + objectLibraries.push_back(tgt); } } } @@ -4556,14 +5809,317 @@ void cmGeneratorTarget::ComputeLinkImplementationLanguages( //---------------------------------------------------------------------------- bool cmGeneratorTarget::HaveBuildTreeRPATH(const std::string& config) const { - if (this->Target->GetPropertyAsBool("SKIP_BUILD_RPATH")) + if (this->GetPropertyAsBool("SKIP_BUILD_RPATH")) { return false; } if(cmLinkImplementationLibraries const* impl = - this->Target->GetLinkImplementationLibraries(config)) + this->GetLinkImplementationLibraries(config)) { return !impl->Libraries.empty(); } return false; } + +//---------------------------------------------------------------------------- +cmLinkImplementationLibraries const* +cmGeneratorTarget::GetLinkImplementationLibraries( + const std::string& config) const +{ + return this->GetLinkImplementationLibrariesInternal(config, this); +} + +//---------------------------------------------------------------------------- +cmLinkImplementationLibraries const* +cmGeneratorTarget::GetLinkImplementationLibrariesInternal( + const std::string& config, cmGeneratorTarget const* head) const +{ + // There is no link implementation for imported targets. + if(this->IsImported()) + { + return 0; + } + + // Populate the link implementation libraries for this configuration. + std::string CONFIG = cmSystemTools::UpperCase(config); + HeadToLinkImplementationMap& hm = + this->LinkImplMap[CONFIG]; + + // If the link implementation does not depend on the head target + // then return the one we computed first. + if(!hm.empty() && !hm.begin()->second.HadHeadSensitiveCondition) + { + return &hm.begin()->second; + } + + cmOptionalLinkImplementation& impl = hm[head]; + if(!impl.LibrariesDone) + { + impl.LibrariesDone = true; + this->ComputeLinkImplementationLibraries(config, impl, head); + } + return &impl; +} + +//---------------------------------------------------------------------------- +bool +cmGeneratorTarget::IsNullImpliedByLinkLibraries(const std::string &p) const +{ + return this->LinkImplicitNullProperties.find(p) + != this->LinkImplicitNullProperties.end(); +} + +//---------------------------------------------------------------------------- +void cmGeneratorTarget::ComputeLinkImplementationLibraries( + const std::string& config, + cmOptionalLinkImplementation& impl, + cmGeneratorTarget const* head) const +{ + cmStringRange entryRange = + this->Target->GetLinkImplementationEntries(); + cmBacktraceRange btRange = + this->Target->GetLinkImplementationBacktraces(); + cmBacktraceRange::const_iterator btIt = btRange.begin(); + // Collect libraries directly linked in this configuration. + for (cmStringRange::const_iterator le = entryRange.begin(), + end = entryRange.end(); le != end; ++le, ++btIt) + { + std::vector<std::string> llibs; + cmGeneratorExpressionDAGChecker dagChecker( + this->GetName(), + "LINK_LIBRARIES", 0, 0); + cmGeneratorExpression ge(*btIt); + cmsys::auto_ptr<cmCompiledGeneratorExpression> const cge = + ge.Parse(*le); + std::string const evaluated = + cge->Evaluate(this->LocalGenerator, config, false, head, &dagChecker); + cmSystemTools::ExpandListArgument(evaluated, llibs); + if(cge->GetHadHeadSensitiveCondition()) + { + impl.HadHeadSensitiveCondition = true; + } + + for(std::vector<std::string>::const_iterator li = llibs.begin(); + li != llibs.end(); ++li) + { + // Skip entries that resolve to the target itself or are empty. + std::string name = this->CheckCMP0004(*li); + if(name == this->GetName() || name.empty()) + { + if(name == this->GetName()) + { + bool noMessage = false; + cmake::MessageType messageType = cmake::FATAL_ERROR; + std::ostringstream e; + switch(this->GetPolicyStatusCMP0038()) + { + case cmPolicies::WARN: + { + e << cmPolicies::GetPolicyWarning(cmPolicies::CMP0038) << "\n"; + messageType = cmake::AUTHOR_WARNING; + } + break; + case cmPolicies::OLD: + noMessage = true; + case cmPolicies::REQUIRED_IF_USED: + case cmPolicies::REQUIRED_ALWAYS: + case cmPolicies::NEW: + // Issue the fatal message. + break; + } + + if(!noMessage) + { + e << "Target \"" << this->GetName() << "\" links to itself."; + this->LocalGenerator->GetCMakeInstance()->IssueMessage( + messageType, e.str(), this->GetBacktrace()); + if (messageType == cmake::FATAL_ERROR) + { + return; + } + } + } + continue; + } + + // The entry is meant for this configuration. + impl.Libraries.push_back( + cmLinkImplItem(name, this->FindTargetToLink(name), + *btIt, evaluated != *le)); + } + + std::set<std::string> const& seenProps = cge->GetSeenTargetProperties(); + for (std::set<std::string>::const_iterator it = seenProps.begin(); + it != seenProps.end(); ++it) + { + if (!this->GetProperty(*it)) + { + this->LinkImplicitNullProperties.insert(*it); + } + } + cge->GetMaxLanguageStandard(this, + this->MaxLanguageStandards); + } + + // Get the list of configurations considered to be DEBUG. + std::vector<std::string> debugConfigs = + this->Makefile->GetCMakeInstance()->GetDebugConfigs(); + + cmTargetLinkLibraryType linkType = + CMP0003_ComputeLinkType(config, debugConfigs); + cmTarget::LinkLibraryVectorType const& oldllibs = + this->Target->GetOriginalLinkLibraries(); + for(cmTarget::LinkLibraryVectorType::const_iterator li = oldllibs.begin(); + li != oldllibs.end(); ++li) + { + if(li->second != GENERAL_LibraryType && li->second != linkType) + { + std::string name = this->CheckCMP0004(li->first); + if(name == this->GetName() || name.empty()) + { + continue; + } + // Support OLD behavior for CMP0003. + impl.WrongConfigLibraries.push_back( + cmLinkItem(name, this->FindTargetToLink(name))); + } + } +} + +//---------------------------------------------------------------------------- +cmGeneratorTarget* +cmGeneratorTarget::FindTargetToLink(std::string const& name) const +{ + cmGeneratorTarget* tgt = + this->LocalGenerator->FindGeneratorTargetToUse(name); + + // Skip targets that will not really be linked. This is probably a + // name conflict between an external library and an executable + // within the project. + if(tgt && tgt->GetType() == cmState::EXECUTABLE && + !tgt->IsExecutableWithExports()) + { + tgt = 0; + } + + if(tgt && tgt->GetType() == cmState::OBJECT_LIBRARY) + { + std::ostringstream e; + e << "Target \"" << this->GetName() << "\" links to " + "OBJECT library \"" << tgt->GetName() << "\" but this is not " + "allowed. " + "One may link only to STATIC or SHARED libraries, or to executables " + "with the ENABLE_EXPORTS property set."; + cmake* cm = this->LocalGenerator->GetCMakeInstance(); + cm->IssueMessage(cmake::FATAL_ERROR, e.str(), + this->GetBacktrace()); + tgt = 0; + } + + return tgt; +} + +//---------------------------------------------------------------------------- +std::string +cmGeneratorTarget::GetPDBDirectory(const std::string& config) const +{ + if(OutputInfo const* info = this->GetOutputInfo(config)) + { + // Return the directory in which the target will be built. + return info->PdbDir; + } + return ""; +} + +//---------------------------------------------------------------------------- +bool cmGeneratorTarget::HasImplibGNUtoMS() const +{ + return this->HasImportLibrary() + && this->GetPropertyAsBool("GNUtoMS"); +} + +//---------------------------------------------------------------------------- +bool cmGeneratorTarget::GetImplibGNUtoMS(std::string const& gnuName, + std::string& out, const char* newExt) const +{ + if(this->HasImplibGNUtoMS() && + gnuName.size() > 6 && gnuName.substr(gnuName.size()-6) == ".dll.a") + { + out = gnuName.substr(0, gnuName.size()-6); + out += newExt? newExt : ".lib"; + return true; + } + return false; +} + +//---------------------------------------------------------------------------- +bool cmGeneratorTarget::IsExecutableWithExports() const +{ + return (this->GetType() == cmState::EXECUTABLE && + this->GetPropertyAsBool("ENABLE_EXPORTS")); +} + +//---------------------------------------------------------------------------- +bool cmGeneratorTarget::HasImportLibrary() const +{ + return (this->IsDLLPlatform() && + (this->GetType() == cmState::SHARED_LIBRARY || + this->IsExecutableWithExports())); +} + +//---------------------------------------------------------------------------- +std::string cmGeneratorTarget::GetSupportDirectory() const +{ + std::string dir = this->LocalGenerator->GetCurrentBinaryDirectory(); + dir += cmake::GetCMakeFilesDirectory(); + dir += "/"; + dir += this->GetName(); +#if defined(__VMS) + dir += "_dir"; +#else + dir += ".dir"; +#endif + return dir; +} + +//---------------------------------------------------------------------------- +bool cmGeneratorTarget::IsLinkable() const +{ + return (this->GetType() == cmState::STATIC_LIBRARY || + this->GetType() == cmState::SHARED_LIBRARY || + this->GetType() == cmState::MODULE_LIBRARY || + this->GetType() == cmState::UNKNOWN_LIBRARY || + this->GetType() == cmState::INTERFACE_LIBRARY || + this->IsExecutableWithExports()); +} + +//---------------------------------------------------------------------------- +bool cmGeneratorTarget::IsFrameworkOnApple() const +{ + return (this->GetType() == cmState::SHARED_LIBRARY && + this->Makefile->IsOn("APPLE") && + this->GetPropertyAsBool("FRAMEWORK")); +} + +//---------------------------------------------------------------------------- +bool cmGeneratorTarget::IsAppBundleOnApple() const +{ + return (this->GetType() == cmState::EXECUTABLE && + this->Makefile->IsOn("APPLE") && + this->GetPropertyAsBool("MACOSX_BUNDLE")); +} + +//---------------------------------------------------------------------------- +bool cmGeneratorTarget::IsXCTestOnApple() const +{ + return (this->IsCFBundleOnApple() && + this->GetPropertyAsBool("XCTEST")); +} + +//---------------------------------------------------------------------------- +bool cmGeneratorTarget::IsCFBundleOnApple() const +{ + return (this->GetType() == cmState::MODULE_LIBRARY && + this->Makefile->IsOn("APPLE") && + this->GetPropertyAsBool("BUNDLE")); +} diff --git a/Source/cmGeneratorTarget.h b/Source/cmGeneratorTarget.h index 916f281..bd23477 100644 --- a/Source/cmGeneratorTarget.h +++ b/Source/cmGeneratorTarget.h @@ -31,8 +31,21 @@ public: cmLocalGenerator* GetLocalGenerator() const; bool IsImported() const; + bool IsImportedGloballyVisible() const; const char *GetLocation(const std::string& config) const; + std::vector<cmCustomCommand> const &GetPreBuildCommands() const; + std::vector<cmCustomCommand> const &GetPreLinkCommands() const; + std::vector<cmCustomCommand> const &GetPostBuildCommands() const; + +#define DECLARE_TARGET_POLICY(POLICY) \ + cmPolicies::PolicyStatus GetPolicyStatus ## POLICY () const \ + { return this->PolicyMap.Get(cmPolicies::POLICY); } + + CM_FOR_EACH_TARGET_POLICY(DECLARE_TARGET_POLICY) + +#undef DECLARE_TARGET_POLICY + /** Get the location of the target in the build tree with a placeholder referencing the configuration in the native build system. This location is suitable for use as the LOCATION target property. */ @@ -41,8 +54,11 @@ public: cmComputeLinkInformation* GetLinkInformation(const std::string& config) const; - int GetType() const; + cmState::TargetType GetType() const; std::string GetName() const; + std::string GetExportName() const; + + std::vector<std::string> GetPropertyKeys() const; const char *GetProperty(const std::string& prop) const; bool GetPropertyAsBool(const std::string& prop) const; void GetSourceFiles(std::vector<cmSourceFile*>& files, @@ -82,6 +98,8 @@ public: void GetExpectedXamlSources(std::set<std::string>&, const std::string& config) const; + std::set<cmLinkItem>const& GetUtilityItems() const; + void ComputeObjectMapping(); const char* GetFeature(const std::string& feature, @@ -109,19 +127,19 @@ public: const std::string& config) const; cmLinkInterface const* GetLinkInterface(const std::string& config, - cmTarget const* headTarget) const; + const cmGeneratorTarget* headTarget) const; void ComputeLinkInterface(const std::string& config, cmOptionalLinkInterface& iface, - cmTarget const* head) const; + const cmGeneratorTarget* head) const; cmLinkInterfaceLibraries const* GetLinkInterfaceLibraries(const std::string& config, - cmTarget const* headTarget, + const cmGeneratorTarget* headTarget, bool usage_requirements_only) const; void ComputeLinkInterfaceLibraries(const std::string& config, cmOptionalLinkInterface &iface, - cmTarget const* head, + const cmGeneratorTarget* head, bool usage_requirements_only) const; /** Get the full path to the target according to the settings in its @@ -149,6 +167,10 @@ public: std::string GetFrameworkDirectory(const std::string& config, bool rootDir) const; + /** Return the framework version string. Undefined if + IsFrameworkOnApple returns false. */ + std::string GetFrameworkVersion() const; + /** @return the Mac CFBundle directory without the base */ std::string GetCFBundleDirectory(const std::string& config, bool contentOnly) const; @@ -162,6 +184,20 @@ public: * install tree. For example: "\@rpath/" or "\@loader_path/". */ std::string GetInstallNameDirForInstallTree() const; + cmListFileBacktrace GetBacktrace() const; + + const std::vector<std::string>& GetLinkDirectories() const; + + std::set<std::string>const& GetUtilities() const; + cmListFileBacktrace const* GetUtilityBacktrace(const std::string& u) const; + + bool LinkLanguagePropagatesToDependents() const + { return this->GetType() == cmState::STATIC_LIBRARY; } + + /** Get the macro to define when building sources in this target. + If no macro should be defined null is returned. */ + const char* GetExportMacro() const; + /** Get the soname of the target. Allowed only for a shared library. */ std::string GetSOName(const std::string& config) const; @@ -184,7 +220,13 @@ public: cmLocalGenerator* LocalGenerator; cmGlobalGenerator const* GlobalGenerator; - std::string GetModuleDefinitionFile(const std::string& config) const; + cmSourceFile const* GetModuleDefinitionFile(const std::string& config) const; + + /** Return whether or not the target is for a DLL platform. */ + bool IsDLLPlatform() const; + + /** @return whether this target have a well defined output file name. */ + bool HaveWellDefinedOutputFiles() const; /** Link information from the transitive closure of the link implementation and the interfaces of its dependencies. */ @@ -207,6 +249,15 @@ public: cmOptionalLinkImplementation& impl ) const; + cmLinkImplementationLibraries const* + GetLinkImplementationLibraries(const std::string& config) const; + + void ComputeLinkImplementationLibraries(const std::string& config, + cmOptionalLinkImplementation& impl, + const cmGeneratorTarget* head) const; + + cmGeneratorTarget* FindTargetToLink(std::string const& name) const; + // Compute the set of languages compiled by the target. This is // computed every time it is called because the languages can change // when source file properties are changed and we do not have enough @@ -215,6 +266,12 @@ public: void GetLanguages(std::set<std::string>& languages, std::string const& config) const; + void + GetObjectLibrariesCMP0026(std::vector<cmGeneratorTarget*>& objlibs) const; + + std::string GetFullNameImported(const std::string& config, + bool implib) const; + bool GetConfigCommonSourceFiles(std::vector<cmSourceFile*>& files) const; bool HaveBuildTreeRPATH(const std::string& config) const; @@ -261,6 +318,13 @@ public: */ void TraceDependencies(); + /** Get the directory in which this target will be built. If the + configuration name is given then the generator will add its + subdirectory for that configuration. Otherwise just the canonical + output directory is given. */ + std::string GetDirectory(const std::string& config = "", + bool implib = false) const; + /** Get the directory in which to place the target compiler .pdb file. If the configuration name is given then the generator will add its subdirectory for that configuration. Otherwise just the canonical @@ -271,6 +335,22 @@ public: std::vector<cmSourceFile*> const* GetSourceDepends(cmSourceFile const* sf) const; + /** Return whether this target uses the default value for its output + directory. */ + bool UsesDefaultOutputDir(const std::string& config, bool implib) const; + + // Cache target output paths for each configuration. + struct OutputInfo + { + std::string OutDir; + std::string ImpDir; + std::string PdbDir; + bool empty() const + { return OutDir.empty() && ImpDir.empty() && PdbDir.empty(); } + }; + + OutputInfo const* GetOutputInfo(const std::string& config) const; + /** Get the name of the pdb file for the target. */ std::string GetPDBName(const std::string& config="") const; @@ -287,6 +367,8 @@ public: typedef std::map<std::string, CompileInfo> CompileInfoMapType; mutable CompileInfoMapType CompileInfoMap; + bool IsNullImpliedByLinkLibraries(const std::string &p) const; + /** Get the name of the compiler pdb file for the target. */ std::string GetCompilePDBName(const std::string& config="") const; @@ -296,6 +378,9 @@ public: // Get the target base name. std::string GetOutputName(const std::string& config, bool implib) const; + void AddSource(const std::string& src); + void AddTracedSources(std::vector<std::string> const& srcs); + /** * Flags for a given source file as used in this target. Typically assigned * via SET_TARGET_PROPERTIES when the property is a list of source files. @@ -342,9 +427,47 @@ public: /** Return true if builtin chrpath will work for this target */ bool IsChrpathUsed(const std::string& config) const; + /** Get the directory in which this targets .pdb files will be placed. + If the configuration name is given then the generator will add its + subdirectory for that configuration. Otherwise just the canonical + pdb output directory is given. */ + std::string GetPDBDirectory(const std::string& config) const; + ///! Return the preferred linker language for this target std::string GetLinkerLanguage(const std::string& config = "") const; + /** Does this target have a GNU implib to convert to MS format? */ + bool HasImplibGNUtoMS() const; + + /** Convert the given GNU import library name (.dll.a) to a name with a new + extension (.lib or ${CMAKE_IMPORT_LIBRARY_SUFFIX}). */ + bool GetImplibGNUtoMS(std::string const& gnuName, std::string& out, + const char* newExt = 0) const; + + bool IsExecutableWithExports() const; + + /** Return whether or not the target has a DLL import library. */ + bool HasImportLibrary() const; + + /** Get a build-tree directory in which to place target support files. */ + std::string GetSupportDirectory() const; + + /** Return whether this target may be used to link another target. */ + bool IsLinkable() const; + + /** Return whether this target is a shared library Framework on + Apple. */ + bool IsFrameworkOnApple() const; + + /** Return whether this target is an executable Bundle on Apple. */ + bool IsAppBundleOnApple() const; + + /** Return whether this target is a XCTest on Apple. */ + bool IsXCTestOnApple() const; + + /** Return whether this target is a CFBundle (plugin) on Apple. */ + bool IsCFBundleOnApple() const; + struct SourceFileFlags GetTargetSourceFileFlags(const cmSourceFile* sf) const; @@ -366,15 +489,42 @@ public: class TargetPropertyEntry; + bool HaveInstallTreeRPATH() const; + + /** Whether this library has \@rpath and platform supports it. */ + bool HasMacOSXRpathInstallNameDir(const std::string& config) const; + + /** Whether this library defaults to \@rpath. */ + bool MacOSXRpathInstallNameDirDefault() const; + + /** Test for special case of a third-party shared library that has + no soname at all. */ + bool IsImportedSharedLibWithoutSOName(const std::string& config) const; + + const char* ImportedGetLocation(const std::string& config) const; + + /** Get the target major and minor version numbers interpreted from + the VERSION property. Version 0 is returned if the property is + not set or cannot be parsed. */ + void GetTargetVersion(int& major, int& minor) const; + + /** Get the target major, minor, and patch version numbers + interpreted from the VERSION or SOVERSION property. Version 0 + is returned if the property is not set or cannot be parsed. */ + void + GetTargetVersion(bool soversion, int& major, int& minor, int& patch) const; + private: friend class cmTargetTraceDependencies; struct SourceEntry { std::vector<cmSourceFile*> Depends; }; typedef std::map<cmSourceFile const*, SourceEntry> SourceEntriesType; - SourceEntriesType SourceEntries; + SourceEntriesType SourceDepends; mutable std::map<cmSourceFile const*, std::string> Objects; std::set<cmSourceFile const*> ExplicitObjectName; mutable std::map<std::string, std::vector<std::string> > SystemIncludesCache; + mutable std::string ExportMacro; + void ConstructSourceFileFlags() const; mutable bool SourceFileFlagsConstructed; mutable std::map<cmSourceFile const*, SourceFileFlags> SourceFlagsMap; @@ -390,6 +540,16 @@ private: typedef std::map<std::string, LinkClosure> LinkClosureMapType; mutable LinkClosureMapType LinkClosureMap; + // Returns ARCHIVE, LIBRARY, or RUNTIME based on platform and type. + const char* GetOutputTargetType(bool implib) const; + + void ComputeVersionedName(std::string& vName, + std::string const& prefix, + std::string const& base, + std::string const& suffix, + std::string const& name, + const char* version) const; + struct CompatibleInterfacesBase { std::set<std::string> PropsBool; @@ -417,7 +577,7 @@ private: cmGeneratorTarget(cmGeneratorTarget const&); void operator=(cmGeneratorTarget const&); - struct LinkImplClosure: public std::vector<cmTarget const*> + struct LinkImplClosure: public std::vector<cmGeneratorTarget const*> { LinkImplClosure(): Done(false) {} bool Done; @@ -434,44 +594,108 @@ private: cmHeadToLinkInterfaceMap& GetHeadToLinkInterfaceUsageRequirementsMap( std::string const& config) const; + // Cache import information from properties for each configuration. + struct ImportInfo + { + ImportInfo(): NoSOName(false), Multiplicity(0) {} + bool NoSOName; + int Multiplicity; + std::string Location; + std::string SOName; + std::string ImportLibrary; + std::string Languages; + std::string Libraries; + std::string LibrariesProp; + std::string SharedDeps; + }; + + typedef std::map<std::string, ImportInfo> ImportInfoMapType; + mutable ImportInfoMapType ImportInfoMap; + void ComputeImportInfo(std::string const& desired_config, + ImportInfo& info) const; + ImportInfo const* GetImportInfo(const std::string& config) const; + + /** Strip off leading and trailing whitespace from an item named in + the link dependencies of this target. */ + std::string CheckCMP0004(std::string const& item) const; + cmLinkInterface const* - GetImportLinkInterface(const std::string& config, cmTarget const* head, + GetImportLinkInterface(const std::string& config, + const cmGeneratorTarget* head, bool usage_requirements_only) const; + typedef std::map<std::string, std::vector<cmSourceFile*> > + SourceFilesMapType; + mutable SourceFilesMapType SourceFilesMap; + std::vector<TargetPropertyEntry*> IncludeDirectoriesEntries; std::vector<TargetPropertyEntry*> CompileOptionsEntries; std::vector<TargetPropertyEntry*> CompileFeaturesEntries; std::vector<TargetPropertyEntry*> CompileDefinitionsEntries; + std::vector<TargetPropertyEntry*> SourceEntries; + mutable std::set<std::string> LinkImplicitNullProperties; void ExpandLinkItems(std::string const& prop, std::string const& value, - std::string const& config, cmTarget const* headTarget, + std::string const& config, + const cmGeneratorTarget* headTarget, bool usage_requirements_only, std::vector<cmLinkItem>& items, bool& hadHeadSensitiveCondition) const; void LookupLinkItems(std::vector<std::string> const& names, std::vector<cmLinkItem>& items) const; + void GetSourceFiles(std::vector<std::string>& files, + const std::string& config) const; + + struct HeadToLinkImplementationMap: + public std::map<cmGeneratorTarget const*, cmOptionalLinkImplementation> {}; + typedef std::map<std::string, + HeadToLinkImplementationMap> LinkImplMapType; + mutable LinkImplMapType LinkImplMap; + + cmLinkImplementationLibraries const* + GetLinkImplementationLibrariesInternal(const std::string& config, + const cmGeneratorTarget* head) const; + bool + ComputeOutputDir(const std::string& config, + bool implib, std::string& out) const; + + typedef std::map<std::string, OutputInfo> OutputInfoMapType; + mutable OutputInfoMapType OutputInfoMap; + typedef std::pair<std::string, bool> OutputNameKey; typedef std::map<OutputNameKey, std::string> OutputNameMapType; mutable OutputNameMapType OutputNameMap; + mutable std::set<cmLinkItem> UtilityItems; + cmPolicies::PolicyMap PolicyMap; mutable bool PolicyWarnedCMP0022; mutable bool DebugIncludesDone; mutable bool DebugCompileOptionsDone; mutable bool DebugCompileFeaturesDone; mutable bool DebugCompileDefinitionsDone; + mutable bool DebugSourcesDone; + mutable bool LinkImplementationLanguageIsContextDependent; + mutable bool UtilityItemsDone; + bool DLLPlatform; + + bool ComputePDBOutputDir(const std::string& kind, const std::string& config, + std::string& out) const; public: - std::vector<cmTarget const*> const& - GetLinkImplementationClosure(const std::string& config) const; + const std::vector<const cmGeneratorTarget*>& + GetLinkImplementationClosure(const std::string& config) const; -}; + mutable std::map<std::string, std::string> MaxLanguageStandards; + std::map<std::string, std::string> const& + GetMaxLanguageStandards() const + { + return this->MaxLanguageStandards; + } -struct cmStrictTargetComparison { - bool operator()(cmTarget const* t1, cmTarget const* t2) const; + struct StrictTargetComparison { + bool operator()(cmGeneratorTarget const* t1, + cmGeneratorTarget const* t2) const; + }; }; -typedef std::map<cmTarget const*, - cmGeneratorTarget*, - cmStrictTargetComparison> cmGeneratorTargetsType; - #endif diff --git a/Source/cmGetCMakePropertyCommand.cxx b/Source/cmGetCMakePropertyCommand.cxx index 248ce59..1a91183 100644 --- a/Source/cmGetCMakePropertyCommand.cxx +++ b/Source/cmGetCMakePropertyCommand.cxx @@ -12,7 +12,6 @@ #include "cmGetCMakePropertyCommand.h" #include "cmGlobalGenerator.h" -#include "cmLocalGenerator.h" #include "cmake.h" #include "cmState.h" #include "cmAlgorithms.h" diff --git a/Source/cmGetPropertyCommand.cxx b/Source/cmGetPropertyCommand.cxx index 4c42f53..617a811 100644 --- a/Source/cmGetPropertyCommand.cxx +++ b/Source/cmGetPropertyCommand.cxx @@ -15,7 +15,6 @@ #include "cmState.h" #include "cmTest.h" #include "cmGlobalGenerator.h" -#include "cmLocalGenerator.h" #include "cmSourceFile.h" #include "cmPropertyDefinition.h" diff --git a/Source/cmGhsMultiTargetGenerator.cxx b/Source/cmGhsMultiTargetGenerator.cxx index cae5c2f..18e140e 100644 --- a/Source/cmGhsMultiTargetGenerator.cxx +++ b/Source/cmGhsMultiTargetGenerator.cxx @@ -22,23 +22,22 @@ std::string const cmGhsMultiTargetGenerator::DDOption("-dynamic"); cmGhsMultiTargetGenerator::cmGhsMultiTargetGenerator(cmGeneratorTarget *target) - : Target(target->Target) - , GeneratorTarget(target) + : GeneratorTarget(target) , LocalGenerator(static_cast<cmLocalGhsMultiGenerator *>( target->GetLocalGenerator())) , Makefile(target->Target->GetMakefile()) - , TargetGroup(DetermineIfTargetGroup(target->Target)) + , TargetGroup(DetermineIfTargetGroup(target)) , DynamicDownload(false) { - this->RelBuildFilePath = this->GetRelBuildFilePath(target->Target); + this->RelBuildFilePath = this->GetRelBuildFilePath(target); this->RelOutputFileName = - this->RelBuildFilePath + this->Target->GetName() + ".a"; + this->RelBuildFilePath + target->GetName() + ".a"; this->RelBuildFileName = this->RelBuildFilePath; - this->RelBuildFileName += this->GetBuildFileName(target->Target); + this->RelBuildFileName += this->GetBuildFileName(target); - std::string absPathToRoot = this->GetAbsPathToRoot(target->Target); + std::string absPathToRoot = this->GetAbsPathToRoot(target); absPathToRoot = this->AddSlashIfNeededToPath(absPathToRoot); this->AbsBuildFilePath = absPathToRoot + this->RelBuildFilePath; this->AbsBuildFileName = absPathToRoot + this->RelBuildFileName; @@ -51,7 +50,8 @@ cmGhsMultiTargetGenerator::~cmGhsMultiTargetGenerator() } std::string -cmGhsMultiTargetGenerator::GetRelBuildFilePath(const cmTarget *target) +cmGhsMultiTargetGenerator::GetRelBuildFilePath( + const cmGeneratorTarget *target) { std::string output; char const *folderProp = target->GetProperty("FOLDER"); @@ -66,13 +66,13 @@ cmGhsMultiTargetGenerator::GetRelBuildFilePath(const cmTarget *target) } std::string -cmGhsMultiTargetGenerator::GetAbsPathToRoot(const cmTarget *target) +cmGhsMultiTargetGenerator::GetAbsPathToRoot(const cmGeneratorTarget *target) { - return target->GetMakefile()->GetHomeOutputDirectory(); + return target->GetLocalGenerator()->GetBinaryDirectory(); } std::string -cmGhsMultiTargetGenerator::GetAbsBuildFilePath(const cmTarget *target) +cmGhsMultiTargetGenerator::GetAbsBuildFilePath(const cmGeneratorTarget *target) { std::string output; output = cmGhsMultiTargetGenerator::GetAbsPathToRoot(target); @@ -82,7 +82,7 @@ cmGhsMultiTargetGenerator::GetAbsBuildFilePath(const cmTarget *target) } std::string -cmGhsMultiTargetGenerator::GetRelBuildFileName(const cmTarget *target) +cmGhsMultiTargetGenerator::GetRelBuildFileName(const cmGeneratorTarget *target) { std::string output; output = cmGhsMultiTargetGenerator::GetRelBuildFilePath(target); @@ -91,7 +91,8 @@ cmGhsMultiTargetGenerator::GetRelBuildFileName(const cmTarget *target) return output; } -std::string cmGhsMultiTargetGenerator::GetBuildFileName(const cmTarget *target) +std::string +cmGhsMultiTargetGenerator::GetBuildFileName(const cmGeneratorTarget *target) { std::string output; output = target->GetName(); @@ -146,7 +147,7 @@ void cmGhsMultiTargetGenerator::Generate() this->WriteCompilerFlags(config, language); this->WriteCompilerDefinitions(config, language); this->WriteIncludes(config, language); - if (this->Target->GetType() == cmTarget::EXECUTABLE) + if (this->GeneratorTarget->GetType() == cmState::EXECUTABLE) { this->WriteTargetLinkLibraries(); } @@ -159,7 +160,8 @@ void cmGhsMultiTargetGenerator::Generate() bool cmGhsMultiTargetGenerator::IncludeThisTarget() { bool output = true; - char const *excludeFromAll = this->Target->GetProperty("EXCLUDE_FROM_ALL"); + char const *excludeFromAll = + this->GeneratorTarget->GetProperty("EXCLUDE_FROM_ALL"); if (NULL != excludeFromAll && '1' == excludeFromAll[0] && '\0' == excludeFromAll[1]) { @@ -172,23 +174,24 @@ std::vector<cmSourceFile *> cmGhsMultiTargetGenerator::GetSources() const { std::vector<cmSourceFile *> output; std::string config = this->Makefile->GetSafeDefinition("CMAKE_BUILD_TYPE"); - this->Target->GetSourceFiles(output, config); + this->GeneratorTarget->GetSourceFiles(output, config); return output; } GhsMultiGpj::Types cmGhsMultiTargetGenerator::GetGpjTag() const { - return cmGhsMultiTargetGenerator::GetGpjTag(this->Target); + return cmGhsMultiTargetGenerator::GetGpjTag(this->GeneratorTarget); } -GhsMultiGpj::Types cmGhsMultiTargetGenerator::GetGpjTag(const cmTarget *target) +GhsMultiGpj::Types cmGhsMultiTargetGenerator::GetGpjTag( + const cmGeneratorTarget *target) { GhsMultiGpj::Types output; if (cmGhsMultiTargetGenerator::DetermineIfTargetGroup(target)) { output = GhsMultiGpj::INTERGRITY_APPLICATION; } - else if (target->GetType() == cmTarget::STATIC_LIBRARY) + else if (target->GetType() == cmState::STATIC_LIBRARY) { output = GhsMultiGpj::LIBRARY; } @@ -212,13 +215,13 @@ void cmGhsMultiTargetGenerator::WriteTypeSpecifics(const std::string &config, std::string outputDir(this->GetOutputDirectory(config)); std::string outputFilename(this->GetOutputFilename(config)); - if (this->Target->GetType() == cmTarget::STATIC_LIBRARY) + if (this->GeneratorTarget->GetType() == cmState::STATIC_LIBRARY) { - *this->GetFolderBuildStreams() << " {optgroup=GhsCommonOptions} -o \"" + *this->GetFolderBuildStreams() << " -o \"" << outputDir << outputFilename << ".a\"" << std::endl; } - else if (this->Target->GetType() == cmTarget::EXECUTABLE) + else if (this->GeneratorTarget->GetType() == cmState::EXECUTABLE) { if (notKernel && !this->IsTargetGroup()) { @@ -227,7 +230,7 @@ void cmGhsMultiTargetGenerator::WriteTypeSpecifics(const std::string &config, if (this->IsTargetGroup()) { *this->GetFolderBuildStreams() - << " {optgroup=GhsCommonOptions} -o \"" << outputDir + << " -o \"" << outputDir << outputFilename << ".elf\"" << std::endl; *this->GetFolderBuildStreams() << " :extraOutputFile=\"" << outputDir << outputFilename << ".elf.ael\"" @@ -235,7 +238,7 @@ void cmGhsMultiTargetGenerator::WriteTypeSpecifics(const std::string &config, } else { - *this->GetFolderBuildStreams() << " {optgroup=GhsCommonOptions} -o \"" + *this->GetFolderBuildStreams() << " -o \"" << outputDir << outputFilename << ".as\"" << std::endl; } @@ -262,8 +265,11 @@ void cmGhsMultiTargetGenerator::SetCompilerFlags(std::string const &config, this->LocalGenerator->AddLanguageFlags( flags, lang + std::string("_GHS_KERNEL"), config); } - this->LocalGenerator->AddCMP0018Flags(flags, this->Target, lang, config); - this->LocalGenerator->AddVisibilityPresetFlags(flags, this->Target, lang); + this->LocalGenerator->AddCMP0018Flags(flags, this->GeneratorTarget, + lang, config); + this->LocalGenerator->AddVisibilityPresetFlags(flags, + this->GeneratorTarget, + lang); // Append old-style preprocessor definition flags. if (std::string(" ") != std::string(this->Makefile->GetDefineFlags())) @@ -273,7 +279,8 @@ void cmGhsMultiTargetGenerator::SetCompilerFlags(std::string const &config, } // Add target-specific flags. - this->LocalGenerator->AddCompileOptions(flags, this->Target, lang, config); + this->LocalGenerator->AddCompileOptions(flags, this->GeneratorTarget, + lang, config); std::map<std::string, std::string>::value_type entry(language, flags); i = this->FlagsByLanguage.insert(entry).first; @@ -290,13 +297,14 @@ std::string cmGhsMultiTargetGenerator::GetDefines(const std::string &language, std::set<std::string> defines; const char *lang = language.c_str(); // Add the export symbol definition for shared library objects. - if (const char *exportMacro = this->Target->GetExportMacro()) + if (const char *exportMacro = this->GeneratorTarget->GetExportMacro()) { this->LocalGenerator->AppendDefines(defines, exportMacro); } // Add preprocessor definitions for this target and configuration. - this->LocalGenerator->AddCompileDefinitions(defines, this->Target, config, + this->LocalGenerator->AddCompileDefinitions(defines, + this->GeneratorTarget, config, language); std::string definesString; @@ -359,13 +367,13 @@ void cmGhsMultiTargetGenerator::WriteTargetLinkLibraries() for (cmTargetDependSet::iterator tdsI = tds.begin(); tdsI != tds.end(); ++tdsI) { - const cmTarget *tg = (*tdsI)->Target; + const cmGeneratorTarget *tg = *tdsI; *this->GetFolderBuildStreams() << " -L\"" << GetAbsBuildFilePath(tg) << "\"" << std::endl; } // library targets cmTarget::LinkLibraryVectorType llv = - this->Target->GetOriginalLinkLibraries(); + this->GeneratorTarget->Target->GetOriginalLinkLibraries(); for (cmTarget::LinkLibraryVectorType::const_iterator llvI = llv.begin(); llvI != llv.end(); ++llvI) { @@ -383,10 +391,12 @@ void cmGhsMultiTargetGenerator::WriteTargetLinkLibraries() void cmGhsMultiTargetGenerator::WriteCustomCommands() { - WriteCustomCommandsHelper(this->Target->GetPreBuildCommands(), - cmTarget::PRE_BUILD); - WriteCustomCommandsHelper(this->Target->GetPostBuildCommands(), - cmTarget::POST_BUILD); + WriteCustomCommandsHelper( + this->GeneratorTarget->GetPreBuildCommands(), + cmTarget::PRE_BUILD); + WriteCustomCommandsHelper( + this->GeneratorTarget->GetPostBuildCommands(), + cmTarget::POST_BUILD); } void cmGhsMultiTargetGenerator::WriteCustomCommandsHelper( @@ -449,7 +459,7 @@ void cmGhsMultiTargetGenerator::WriteSources( cmSystemTools::ConvertToUnixSlashes(sgPath); cmGlobalGhsMultiGenerator::AddFilesUpToPath( this->GetFolderBuildStreams(), &this->FolderBuildStreams, - this->Makefile->GetHomeOutputDirectory(), sgPath, + this->LocalGenerator->GetBinaryDirectory(), sgPath, GhsMultiGpj::SUBPROJECT, this->RelBuildFilePath); std::string fullSourcePath((*si)->GetFullPath()); @@ -510,7 +520,7 @@ cmGhsMultiTargetGenerator::GetOutputDirectory(const std::string &config) const std::string outputDir(AbsBuildFilePath); const char *runtimeOutputProp = - this->Target->GetProperty("RUNTIME_OUTPUT_DIRECTORY"); + this->GeneratorTarget->GetProperty("RUNTIME_OUTPUT_DIRECTORY"); if (NULL != runtimeOutputProp) { outputDir = runtimeOutputProp; @@ -518,7 +528,8 @@ cmGhsMultiTargetGenerator::GetOutputDirectory(const std::string &config) const std::string configCapped(cmSystemTools::UpperCase(config)); const char *runtimeOutputSProp = - this->Target->GetProperty("RUNTIME_OUTPUT_DIRECTORY_" + configCapped); + this->GeneratorTarget + ->GetProperty("RUNTIME_OUTPUT_DIRECTORY_" + configCapped); if (NULL != runtimeOutputSProp) { outputDir = runtimeOutputSProp; @@ -536,9 +547,10 @@ cmGhsMultiTargetGenerator::GetOutputDirectory(const std::string &config) const std::string cmGhsMultiTargetGenerator::GetOutputFilename(const std::string &config) const { - std::string outputFilename(this->Target->GetName()); + std::string outputFilename(this->GeneratorTarget->GetName()); - const char *outputNameProp = this->Target->GetProperty("OUTPUT_NAME"); + const char *outputNameProp = + this->GeneratorTarget->GetProperty("OUTPUT_NAME"); if (NULL != outputNameProp) { outputFilename = outputNameProp; @@ -546,7 +558,7 @@ cmGhsMultiTargetGenerator::GetOutputFilename(const std::string &config) const std::string configCapped(cmSystemTools::UpperCase(config)); const char *outputNameSProp = - this->Target->GetProperty(configCapped + "_OUTPUT_NAME"); + this->GeneratorTarget->GetProperty(configCapped + "_OUTPUT_NAME"); if (NULL != outputNameSProp) { outputFilename = outputNameSProp; @@ -566,12 +578,13 @@ bool cmGhsMultiTargetGenerator::IsNotKernel(std::string const &config, return output; } -bool cmGhsMultiTargetGenerator::DetermineIfTargetGroup(const cmTarget *target) +bool cmGhsMultiTargetGenerator::DetermineIfTargetGroup( + const cmGeneratorTarget *target) { bool output = false; std::vector<cmSourceFile *> sources; std::string config = - target->GetMakefile()->GetSafeDefinition("CMAKE_BUILD_TYPE"); + target->Target->GetMakefile()->GetSafeDefinition("CMAKE_BUILD_TYPE"); target->GetSourceFiles(sources, config); for (std::vector<cmSourceFile *>::const_iterator sources_i = sources.begin(); sources.end() != sources_i; ++sources_i) diff --git a/Source/cmGhsMultiTargetGenerator.h b/Source/cmGhsMultiTargetGenerator.h index c29a31e..327fdef 100644 --- a/Source/cmGhsMultiTargetGenerator.h +++ b/Source/cmGhsMultiTargetGenerator.h @@ -36,7 +36,7 @@ public: bool IncludeThisTarget(); std::vector<cmSourceFile *> GetSources() const; GhsMultiGpj::Types GetGpjTag() const; - static GhsMultiGpj::Types GetGpjTag(const cmTarget *target); + static GhsMultiGpj::Types GetGpjTag(const cmGeneratorTarget* target); const char *GetAbsBuildFilePath() const { return this->AbsBuildFilePath.c_str(); @@ -54,11 +54,11 @@ public: return this->AbsOutputFileName.c_str(); } - static std::string GetRelBuildFilePath(const cmTarget *target); - static std::string GetAbsPathToRoot(const cmTarget *target); - static std::string GetAbsBuildFilePath(const cmTarget *target); - static std::string GetRelBuildFileName(const cmTarget *target); - static std::string GetBuildFileName(const cmTarget *target); + static std::string GetRelBuildFilePath(const cmGeneratorTarget *target); + static std::string GetAbsPathToRoot(const cmGeneratorTarget *target); + static std::string GetAbsBuildFilePath(const cmGeneratorTarget *target); + static std::string GetRelBuildFileName(const cmGeneratorTarget *target); + static std::string GetBuildFileName(const cmGeneratorTarget *target); static std::string AddSlashIfNeededToPath(std::string const &input); private: @@ -95,11 +95,10 @@ private: std::string GetOutputFilename(const std::string &config) const; bool IsNotKernel(std::string const &config, const std::string &language); - static bool DetermineIfTargetGroup(const cmTarget *target); + static bool DetermineIfTargetGroup(const cmGeneratorTarget* target); bool DetermineIfDynamicDownload(std::string const &config, const std::string &language); - cmTarget *Target; cmGeneratorTarget* GeneratorTarget; cmLocalGhsMultiGenerator *LocalGenerator; cmMakefile *Makefile; diff --git a/Source/cmGlobalGenerator.cxx b/Source/cmGlobalGenerator.cxx index 4a48b5d..2126c71 100644 --- a/Source/cmGlobalGenerator.cxx +++ b/Source/cmGlobalGenerator.cxx @@ -48,6 +48,18 @@ #include <assert.h> +bool cmTarget::StrictTargetComparison::operator()(cmTarget const* t1, + cmTarget const* t2) const +{ + int nameResult = strcmp(t1->GetName().c_str(), t2->GetName().c_str()); + if (nameResult == 0) + { + return strcmp(t1->GetMakefile()->GetCurrentBinaryDirectory(), + t2->GetMakefile()->GetCurrentBinaryDirectory()) < 0; + } + return nameResult < 0; +} + cmGlobalGenerator::cmGlobalGenerator(cmake* cm) : CMakeInstance(cm) { @@ -73,7 +85,7 @@ cmGlobalGenerator::cmGlobalGenerator(cmake* cm) this->CurrentMakefile = 0; this->TryCompileOuterMakefile = 0; - this->ConfigureDoneCMP0026 = false; + this->ConfigureDoneCMP0026AndCMP0024 = false; } cmGlobalGenerator::~cmGlobalGenerator() @@ -234,6 +246,16 @@ bool cmGlobalGenerator::GenerateImportFile(const std::string &file) if (it != this->BuildExportSets.end()) { bool result = it->second->GenerateImportFile(); + + if (!this->ConfigureDoneCMP0026AndCMP0024) + { + for (std::vector<cmMakefile*>::const_iterator mit = + this->Makefiles.begin(); mit != this->Makefiles.end(); ++mit) + { + (*mit)->RemoveExportBuildFileGeneratorCMP0024(it->second); + } + } + delete it->second; it->second = 0; this->BuildExportSets.erase(it); @@ -399,7 +421,7 @@ cmGlobalGenerator::EnableLanguage(std::vector<std::string>const& languages, bool fatalError = false; mf->AddDefinition("RUN_CONFIGURE", true); - std::string rootBin = mf->GetHomeOutputDirectory(); + std::string rootBin = this->CMakeInstance->GetHomeOutputDirectory(); rootBin += cmake::GetCMakeFilesDirectory(); // If the configuration files path has been set, @@ -1108,25 +1130,25 @@ void cmGlobalGenerator::Configure() this->FirstTimeProgress = 0.0f; this->ClearGeneratorMembers(); - cmMakefile* dirMf = - new cmMakefile(this, this->GetCMakeInstance()->GetCurrentSnapshot()); - this->Makefiles.push_back(dirMf); + cmState::Snapshot snapshot = this->CMakeInstance->GetCurrentSnapshot(); - // set the Start directories - dirMf->SetCurrentSourceDirectory + snapshot.GetDirectory().SetCurrentSource (this->CMakeInstance->GetHomeDirectory()); - dirMf->SetCurrentBinaryDirectory + snapshot.GetDirectory().SetCurrentBinary (this->CMakeInstance->GetHomeOutputDirectory()); + cmMakefile* dirMf = new cmMakefile(this, snapshot); + this->Makefiles.push_back(dirMf); + this->BinaryDirectories.insert( this->CMakeInstance->GetHomeOutputDirectory()); // now do it - this->ConfigureDoneCMP0026 = false; + this->ConfigureDoneCMP0026AndCMP0024 = false; dirMf->Configure(); dirMf->EnforceDirectoryLevelRules(); - this->ConfigureDoneCMP0026 = true; + this->ConfigureDoneCMP0026AndCMP0024 = true; // Put a copy of each global target in every directory. cmTargets globalTargets; @@ -1186,9 +1208,28 @@ void cmGlobalGenerator::Configure() void cmGlobalGenerator::CreateGenerationObjects(TargetTypes targetTypes) { this->CreateLocalGenerators(); - cmDeleteAll(this->GeneratorTargets); - this->GeneratorTargets.clear(); this->CreateGeneratorTargets(targetTypes); + this->ComputeBuildFileGenerators(); +} + +void cmGlobalGenerator::CreateImportedGenerationObjects(cmMakefile* mf, + const std::vector<std::string>& targets, + std::vector<const cmGeneratorTarget*>& exports) +{ + this->CreateGenerationObjects(ImportedOnly); + std::vector<cmMakefile*>::iterator mfit = + std::find(this->Makefiles.begin(), this->Makefiles.end(), mf); + cmLocalGenerator* lg = + this->LocalGenerators[std::distance(this->Makefiles.begin(), mfit)]; + for (std::vector<std::string>::const_iterator it = targets.begin(); + it != targets.end(); ++it) + { + cmGeneratorTarget* gt = lg->FindGeneratorTargetToUse(*it); + if (gt) + { + exports.push_back(gt); + } + } } cmExportBuildFileGenerator* @@ -1226,6 +1267,20 @@ bool cmGlobalGenerator::CheckALLOW_DUPLICATE_CUSTOM_TARGETS() const return false; } +void cmGlobalGenerator::ComputeBuildFileGenerators() +{ + for (unsigned int i = 0; i < this->LocalGenerators.size(); ++i) + { + std::vector<cmExportBuildFileGenerator*> gens = + this->Makefiles[i]->GetExportBuildFileGenerators(); + for (std::vector<cmExportBuildFileGenerator*>::const_iterator it = + gens.begin(); it != gens.end(); ++it) + { + (*it)->Compute(this->LocalGenerators[i]); + } + } +} + bool cmGlobalGenerator::Compute() { // Some generators track files replaced during the Generate. @@ -1251,7 +1306,7 @@ bool cmGlobalGenerator::Compute() #ifdef CMAKE_BUILD_WITH_CMAKE // Iterate through all targets and set up automoc for those which have // the AUTOMOC, AUTOUIC or AUTORCC property set - std::vector<cmTarget const*> autogenTargets = + std::vector<cmGeneratorTarget const*> autogenTargets = this->CreateQtAutoGeneratorsTargets(); #endif @@ -1264,8 +1319,8 @@ bool cmGlobalGenerator::Compute() } #ifdef CMAKE_BUILD_WITH_CMAKE - for (std::vector<cmTarget const*>::iterator it = autogenTargets.begin(); - it != autogenTargets.end(); ++it) + for (std::vector<cmGeneratorTarget const*>::iterator it = + autogenTargets.begin(); it != autogenTargets.end(); ++it) { cmQtAutoGeneratorInitializer::SetupAutoGenerateTarget(*it); } @@ -1282,12 +1337,7 @@ bool cmGlobalGenerator::Compute() } } - return true; -} - -void cmGlobalGenerator::Generate() -{ - unsigned int i; + this->AddExtraIDETargets(); // Trace the dependencies, after that no custom commands should be added // because their dependencies might not be handled correctly @@ -1307,22 +1357,27 @@ void cmGlobalGenerator::Generate() // Compute the inter-target dependencies. if(!this->ComputeTargetDepends()) { - return; + return false; } + for (i = 0; i < this->LocalGenerators.size(); ++i) + { + this->LocalGenerators[i]->ComputeHomeRelativeOutputPath(); + } + + return true; +} + +void cmGlobalGenerator::Generate() +{ // Create a map from local generator to the complete set of targets // it builds by default. this->InitializeProgressMarks(); this->ProcessEvaluationFiles(); - for (i = 0; i < this->LocalGenerators.size(); ++i) - { - this->LocalGenerators[i]->ComputeHomeRelativeOutputPath(); - } - // Generate project files - for (i = 0; i < this->LocalGenerators.size(); ++i) + for (unsigned int i = 0; i < this->LocalGenerators.size(); ++i) { this->SetCurrentMakefile(this->LocalGenerators[i]->GetMakefile()); this->LocalGenerators[i]->Generate(); @@ -1403,42 +1458,42 @@ bool cmGlobalGenerator::ComputeTargetDepends() } //---------------------------------------------------------------------------- -std::vector<const cmTarget*> +std::vector<const cmGeneratorTarget*> cmGlobalGenerator::CreateQtAutoGeneratorsTargets() { - std::vector<const cmTarget*> autogenTargets; + std::vector<const cmGeneratorTarget*> autogenTargets; #ifdef CMAKE_BUILD_WITH_CMAKE for(unsigned int i=0; i < this->LocalGenerators.size(); ++i) { - cmTargets& targets = - this->LocalGenerators[i]->GetMakefile()->GetTargets(); - std::vector<std::string> targetNames; - targetNames.reserve(targets.size()); - for(cmTargets::iterator ti = targets.begin(); + std::vector<cmGeneratorTarget*> targets = + this->LocalGenerators[i]->GetGeneratorTargets(); + std::vector<cmGeneratorTarget*> filteredTargets; + filteredTargets.reserve(targets.size()); + for(std::vector<cmGeneratorTarget*>::iterator ti = targets.begin(); ti != targets.end(); ++ti) { - if (ti->second.GetType() == cmTarget::GLOBAL_TARGET) + if ((*ti)->GetType() == cmState::GLOBAL_TARGET) { continue; } - if(ti->second.GetType() != cmTarget::EXECUTABLE && - ti->second.GetType() != cmTarget::STATIC_LIBRARY && - ti->second.GetType() != cmTarget::SHARED_LIBRARY && - ti->second.GetType() != cmTarget::MODULE_LIBRARY && - ti->second.GetType() != cmTarget::OBJECT_LIBRARY) + if((*ti)->GetType() != cmState::EXECUTABLE && + (*ti)->GetType() != cmState::STATIC_LIBRARY && + (*ti)->GetType() != cmState::SHARED_LIBRARY && + (*ti)->GetType() != cmState::MODULE_LIBRARY && + (*ti)->GetType() != cmState::OBJECT_LIBRARY) { continue; } - if((!ti->second.GetPropertyAsBool("AUTOMOC") - && !ti->second.GetPropertyAsBool("AUTOUIC") - && !ti->second.GetPropertyAsBool("AUTORCC")) - || ti->second.IsImported()) + if((!(*ti)->GetPropertyAsBool("AUTOMOC") + && !(*ti)->GetPropertyAsBool("AUTOUIC") + && !(*ti)->GetPropertyAsBool("AUTORCC")) + || (*ti)->IsImported()) { continue; } // don't do anything if there is no Qt4 or Qt5Core (which contains moc): - cmMakefile* mf = ti->second.GetMakefile(); + cmMakefile* mf = (*ti)->Target->GetMakefile(); std::string qtMajorVersion = mf->GetSafeDefinition("QT_VERSION_MAJOR"); if (qtMajorVersion == "") { @@ -1449,17 +1504,17 @@ cmGlobalGenerator::CreateQtAutoGeneratorsTargets() continue; } - cmQtAutoGeneratorInitializer::InitializeAutogenSources(&ti->second); - targetNames.push_back(ti->second.GetName()); + cmGeneratorTarget* gt = *ti; + + cmQtAutoGeneratorInitializer::InitializeAutogenSources(gt); + filteredTargets.push_back(gt); } - for(std::vector<std::string>::iterator ti = targetNames.begin(); - ti != targetNames.end(); ++ti) + for(std::vector<cmGeneratorTarget*>::iterator ti = filteredTargets.begin(); + ti != filteredTargets.end(); ++ti) { - cmTarget* target = this->LocalGenerators[i] - ->GetMakefile()->FindTarget(*ti, true); cmQtAutoGeneratorInitializer::InitializeAutogenTarget( - this->LocalGenerators[i], target); - autogenTargets.push_back(target); + this->LocalGenerators[i], *ti); + autogenTargets.push_back(*ti); } } #endif @@ -1484,14 +1539,14 @@ void cmGlobalGenerator::FinalizeTargetCompileInfo() ti != targets.end(); ++ti) { cmTarget* t = &ti->second; - if (t->GetType() == cmTarget::GLOBAL_TARGET) + if (t->GetType() == cmState::GLOBAL_TARGET) { continue; } t->AppendBuildInterfaceIncludes(); - if (t->GetType() == cmTarget::INTERFACE_LIBRARY) + if (t->GetType() == cmState::INTERFACE_LIBRARY) { continue; } @@ -1526,11 +1581,12 @@ void cmGlobalGenerator::FinalizeTargetCompileInfo() } //---------------------------------------------------------------------------- -void cmGlobalGenerator::CreateGeneratorTargets(TargetTypes targetTypes, - cmLocalGenerator *lg) +void cmGlobalGenerator::CreateGeneratorTargets( + TargetTypes targetTypes, + cmMakefile *mf, + cmLocalGenerator *lg, + std::map<cmTarget*, cmGeneratorTarget*> const& importedMap) { - cmGeneratorTargetsType generatorTargets; - cmMakefile* mf = lg->GetMakefile(); if (targetTypes == AllTargets) { cmTargets& targets = mf->GetTargets(); @@ -1539,29 +1595,42 @@ void cmGlobalGenerator::CreateGeneratorTargets(TargetTypes targetTypes, { cmTarget* t = &ti->second; cmGeneratorTarget* gt = new cmGeneratorTarget(t, lg); - this->GeneratorTargets[t] = gt; - generatorTargets[t] = gt; + lg->AddGeneratorTarget(gt); } } + std::vector<cmTarget*> itgts = mf->GetImportedTargets(); + for(std::vector<cmTarget*>::const_iterator - j = mf->GetOwnedImportedTargets().begin(); - j != mf->GetOwnedImportedTargets().end(); ++j) + j = itgts.begin(); j != itgts.end(); ++j) { - cmGeneratorTarget* gt = new cmGeneratorTarget(*j, lg); - this->GeneratorTargets[*j] = gt; - generatorTargets[*j] = gt; + lg->AddImportedGeneratorTarget(importedMap.find(*j)->second); } - mf->SetGeneratorTargets(generatorTargets); } //---------------------------------------------------------------------------- void cmGlobalGenerator::CreateGeneratorTargets(TargetTypes targetTypes) { + std::map<cmTarget*, cmGeneratorTarget*> importedMap; + for(unsigned int i=0; i < this->Makefiles.size(); ++i) + { + cmMakefile* mf = this->Makefiles[i]; + for(std::vector<cmTarget*>::const_iterator + j = mf->GetOwnedImportedTargets().begin(); + j != mf->GetOwnedImportedTargets().end(); ++j) + { + cmLocalGenerator* lg = this->LocalGenerators[i]; + cmGeneratorTarget* gt = new cmGeneratorTarget(*j, lg); + lg->AddOwnedImportedGeneratorTarget(gt); + importedMap[*j] = gt; + } + } + // Construct per-target generator information. for(unsigned int i=0; i < this->LocalGenerators.size(); ++i) { - this->CreateGeneratorTargets(targetTypes, this->LocalGenerators[i]); + this->CreateGeneratorTargets(targetTypes, this->Makefiles[i], + this->LocalGenerators[i], importedMap); } } @@ -1569,9 +1638,6 @@ void cmGlobalGenerator::CreateGeneratorTargets(TargetTypes targetTypes) //---------------------------------------------------------------------------- void cmGlobalGenerator::ClearGeneratorMembers() { - cmDeleteAll(this->GeneratorTargets); - this->GeneratorTargets.clear(); - cmDeleteAll(this->BuildExportSets); this->BuildExportSets.clear(); @@ -1583,8 +1649,6 @@ void cmGlobalGenerator::ClearGeneratorMembers() this->ExportSets.clear(); this->TargetDependencies.clear(); - this->TotalTargets.clear(); - this->ImportedTargets.clear(); this->ProjectMap.clear(); this->RuleHashes.clear(); this->DirectoryContentMap.clear(); @@ -1592,20 +1656,6 @@ void cmGlobalGenerator::ClearGeneratorMembers() } //---------------------------------------------------------------------------- -cmGeneratorTarget* -cmGlobalGenerator::GetGeneratorTarget(cmTarget const* t) const -{ - cmGeneratorTargetsType::const_iterator ti = this->GeneratorTargets.find(t); - if(ti == this->GeneratorTargets.end()) - { - this->CMakeInstance->IssueMessage( - cmake::INTERNAL_ERROR, "Missing cmGeneratorTarget instance!"); - return 0; - } - return ti->second; -} - -//---------------------------------------------------------------------------- void cmGlobalGenerator::ComputeTargetObjectDirectory(cmGeneratorTarget*) const { } @@ -1624,7 +1674,7 @@ void cmGlobalGenerator::CheckTargetProperties() for (cmTargets::iterator l = targets.begin(); l != targets.end(); l++) { - if (l->second.GetType() == cmTarget::INTERFACE_LIBRARY) + if (l->second.GetType() == cmState::INTERFACE_LIBRARY) { continue; } @@ -2032,8 +2082,8 @@ bool cmGlobalGenerator::IsExcluded(cmLocalGenerator* root, bool cmGlobalGenerator::IsExcluded(cmLocalGenerator* root, cmGeneratorTarget* target) const { - if(target->GetType() == cmTarget::INTERFACE_LIBRARY - || target->Target->GetPropertyAsBool("EXCLUDE_FROM_ALL")) + if(target->GetType() == cmState::INTERFACE_LIBRARY + || target->GetPropertyAsBool("EXCLUDE_FROM_ALL")) { // This target is excluded from its directory. return true; @@ -2105,7 +2155,7 @@ cmGlobalGenerator::FindLocalGenerator(const std::string& start_dir) const for(std::vector<cmLocalGenerator*>::const_iterator it = this->LocalGenerators.begin(); it != this->LocalGenerators.end(); ++it) { - std::string sd = (*it)->GetMakefile()->GetCurrentSourceDirectory(); + std::string sd = (*it)->GetCurrentSourceDirectory(); if (sd == start_dir) { return *it; @@ -2115,9 +2165,10 @@ cmGlobalGenerator::FindLocalGenerator(const std::string& start_dir) const } //---------------------------------------------------------------------------- -void cmGlobalGenerator::AddAlias(const std::string& name, cmTarget *tgt) +void cmGlobalGenerator::AddAlias(const std::string& name, + std::string const& tgtName) { - this->AliasTargets[name] = tgt; + this->AliasTargets[name] = tgtName; } //---------------------------------------------------------------------------- @@ -2126,6 +2177,79 @@ bool cmGlobalGenerator::IsAlias(const std::string& name) const return this->AliasTargets.find(name) != this->AliasTargets.end(); } +cmTarget* cmGlobalGenerator::FindTargetImpl(std::string const& name) const +{ + for (unsigned int i = 0; i < this->Makefiles.size(); ++i) + { + cmTargets& tgts = this->Makefiles[i]->GetTargets(); + for (cmTargets::iterator it = tgts.begin(); it != tgts.end(); ++it) + { + if (it->second.GetName() == name) + { + return &it->second; + } + } + } + return 0; +} + +cmGeneratorTarget* +cmGlobalGenerator::FindGeneratorTargetImpl(std::string const& name) const +{ + for (unsigned int i = 0; i < this->LocalGenerators.size(); ++i) + { + std::vector<cmGeneratorTarget*> tgts = + this->LocalGenerators[i]->GetGeneratorTargets(); + for (std::vector<cmGeneratorTarget*>::iterator it = tgts.begin(); + it != tgts.end(); ++it) + { + if ((*it)->GetName() == name) + { + return *it; + } + } + } + return 0; +} + +cmTarget* +cmGlobalGenerator::FindImportedTargetImpl(std::string const& name) const +{ + for (unsigned int i = 0; i < this->Makefiles.size(); ++i) + { + std::vector<cmTarget*> tgts = + this->Makefiles[i]->GetOwnedImportedTargets(); + for (std::vector<cmTarget*>::iterator it = tgts.begin(); + it != tgts.end(); ++it) + { + if ((*it)->GetName() == name && (*it)->IsImportedGloballyVisible()) + { + return *it; + } + } + } + return 0; +} + +cmGeneratorTarget* cmGlobalGenerator::FindImportedGeneratorTargetImpl( + std::string const& name) const +{ + for (unsigned int i = 0; i < this->LocalGenerators.size(); ++i) + { + std::vector<cmGeneratorTarget*> tgts = + this->LocalGenerators[i]->GetImportedGeneratorTargets(); + for (std::vector<cmGeneratorTarget*>::iterator it = tgts.begin(); + it != tgts.end(); ++it) + { + if ((*it)->IsImportedGloballyVisible() && (*it)->GetName() == name) + { + return *it; + } + } + } + return 0; +} + //---------------------------------------------------------------------------- cmTarget* cmGlobalGenerator::FindTarget(const std::string& name, @@ -2133,23 +2257,34 @@ cmGlobalGenerator::FindTarget(const std::string& name, { if (!excludeAliases) { - TargetMap::const_iterator ai = this->AliasTargets.find(name); + std::map<std::string, std::string>::const_iterator ai = + this->AliasTargets.find(name); if (ai != this->AliasTargets.end()) { - return ai->second; + return this->FindTargetImpl(ai->second); } } - TargetMap::const_iterator i = this->TotalTargets.find ( name ); - if ( i != this->TotalTargets.end() ) + if (cmTarget* tgt = this->FindTargetImpl(name)) + { + return tgt; + } + return this->FindImportedTargetImpl(name); +} + +cmGeneratorTarget* +cmGlobalGenerator::FindGeneratorTarget(const std::string& name) const +{ + std::map<std::string, std::string>::const_iterator ai = + this->AliasTargets.find(name); + if (ai != this->AliasTargets.end()) { - return i->second; + return this->FindGeneratorTargetImpl(ai->second); } - i = this->ImportedTargets.find(name); - if ( i != this->ImportedTargets.end() ) + if (cmGeneratorTarget* tgt = this->FindGeneratorTargetImpl(name)) { - return i->second; + return tgt; } - return 0; + return this->FindImportedGeneratorTargetImpl(name); } //---------------------------------------------------------------------------- @@ -2493,7 +2628,7 @@ cmTarget cmGlobalGenerator::CreateGlobalTarget( { // Package cmTarget target; - target.SetType(cmTarget::GLOBAL_TARGET, name); + target.SetType(cmState::GLOBAL_TARGET, name); target.SetProperty("EXCLUDE_FROM_ALL","TRUE"); std::vector<std::string> no_outputs; @@ -2567,18 +2702,6 @@ cmGlobalGenerator::GetTargetDirectDepends(cmGeneratorTarget const* target) return this->TargetDependencies[target]; } -void cmGlobalGenerator::AddTarget(cmTarget* t) -{ - if(t->IsImported()) - { - this->ImportedTargets[t->GetName()] = t; - } - else - { - this->TotalTargets[t->GetName()] = t; - } -} - bool cmGlobalGenerator::IsReservedTarget(std::string const& name) { // The following is a list of targets reserved @@ -2651,31 +2774,30 @@ void cmGlobalGenerator::GetTargetSets(TargetDependSet& projectTargets, { continue; } - cmMakefile* mf = (*i)->GetMakefile(); // Get the targets in the makefile - cmTargets &tgts = mf->GetTargets(); + std::vector<cmGeneratorTarget*> tgts = (*i)->GetGeneratorTargets(); // loop over all the targets - for (cmTargets::iterator l = tgts.begin(); l != tgts.end(); ++l) + for (std::vector<cmGeneratorTarget*>::iterator l = tgts.begin(); + l != tgts.end(); ++l) { - cmTarget* target = &l->second; + cmGeneratorTarget* target = *l; if(this->IsRootOnlyTarget(target) && - target->GetMakefile() != root->GetMakefile()) + target->GetLocalGenerator() != root) { continue; } // put the target in the set of original targets - cmGeneratorTarget* gt = this->GetGeneratorTarget(target); - originalTargets.insert(gt); + originalTargets.insert(target); // Get the set of targets that depend on target - this->AddTargetDepends(gt, projectTargets); + this->AddTargetDepends(target, projectTargets); } } } //---------------------------------------------------------------------------- -bool cmGlobalGenerator::IsRootOnlyTarget(cmTarget* target) const +bool cmGlobalGenerator::IsRootOnlyTarget(cmGeneratorTarget* target) const { - return (target->GetType() == cmTarget::GLOBAL_TARGET || + return (target->GetType() == cmState::GLOBAL_TARGET || target->GetName() == this->GetAllTargetName()); } @@ -2879,29 +3001,31 @@ void cmGlobalGenerator::WriteRuleHashes(std::string const& pfile) //---------------------------------------------------------------------------- void cmGlobalGenerator::WriteSummary() { - cmMakefile* mf = this->LocalGenerators[0]->GetMakefile(); - // Record all target directories in a central location. - std::string fname = mf->GetHomeOutputDirectory(); + std::string fname = this->CMakeInstance->GetHomeOutputDirectory(); fname += cmake::GetCMakeFilesDirectory(); fname += "/TargetDirectories.txt"; cmGeneratedFileStream fout(fname.c_str()); - // Generate summary information files for each target. - for(TargetMap::const_iterator ti = - this->TotalTargets.begin(); ti != this->TotalTargets.end(); ++ti) + for (unsigned int i = 0; i < this->LocalGenerators.size(); ++i) { - if ((ti->second)->GetType() == cmTarget::INTERFACE_LIBRARY) + std::vector<cmGeneratorTarget*> tgts = + this->LocalGenerators[i]->GetGeneratorTargets(); + for (std::vector<cmGeneratorTarget*>::iterator it = tgts.begin(); + it != tgts.end(); ++it) { - continue; + if ((*it)->GetType() == cmState::INTERFACE_LIBRARY) + { + continue; + } + this->WriteSummary(*it); + fout << (*it)->GetSupportDirectory() << "\n"; } - this->WriteSummary(ti->second); - fout << ti->second->GetSupportDirectory() << "\n"; } } //---------------------------------------------------------------------------- -void cmGlobalGenerator::WriteSummary(cmTarget* target) +void cmGlobalGenerator::WriteSummary(cmGeneratorTarget* target) { // Place the labels file in a per-target support directory. std::string dir = target->GetSupportDirectory(); @@ -2944,7 +3068,7 @@ void cmGlobalGenerator::WriteSummary(cmTarget* target) fout << "# Source files and their labels\n"; std::vector<cmSourceFile*> sources; std::vector<std::string> configs; - target->GetMakefile()->GetConfigurations(configs); + target->Target->GetMakefile()->GetConfigurations(configs); if (configs.empty()) { configs.push_back(""); @@ -3004,13 +3128,13 @@ std::string cmGlobalGenerator::EscapeJSON(const std::string& s) { //---------------------------------------------------------------------------- void cmGlobalGenerator::SetFilenameTargetDepends(cmSourceFile* sf, - std::set<cmTarget const*> tgts) + std::set<cmGeneratorTarget const*> tgts) { this->FilenameTargetDepends[sf] = tgts; } //---------------------------------------------------------------------------- -std::set<cmTarget const*> const& +std::set<cmGeneratorTarget const*> const& cmGlobalGenerator::GetFilenameTargetDepends(cmSourceFile* sf) const { return this->FilenameTargetDepends[sf]; } diff --git a/Source/cmGlobalGenerator.h b/Source/cmGlobalGenerator.h index ba74c9e..bc6e17d 100644 --- a/Source/cmGlobalGenerator.h +++ b/Source/cmGlobalGenerator.h @@ -83,13 +83,17 @@ public: */ virtual void Configure(); - virtual bool Compute(); + bool Compute(); + virtual void AddExtraIDETargets() {} enum TargetTypes { AllTargets, ImportedOnly }; + void CreateImportedGenerationObjects(cmMakefile* mf, + std::vector<std::string> const& targets, + std::vector<cmGeneratorTarget const*>& exports); void CreateGenerationObjects(TargetTypes targetTypes = AllTargets); /** @@ -246,7 +250,9 @@ public: cmTarget* FindTarget(const std::string& name, bool excludeAliases = false) const; - void AddAlias(const std::string& name, cmTarget *tgt); + cmGeneratorTarget* FindGeneratorTarget(const std::string& name) const; + + void AddAlias(const std::string& name, const std::string& tgtName); bool IsAlias(const std::string& name) const; /** Determine if a name resolves to a framework on disk or a built target @@ -272,8 +278,6 @@ public: std::set<std::string> const& GetDirectoryContent(std::string const& dir, bool needDisk = true); - void AddTarget(cmTarget* t); - static bool IsReservedTarget(std::string const& name); virtual const char* GetAllTargetName() const { return "ALL_BUILD"; } @@ -299,14 +303,6 @@ public: TargetDependSet const& GetTargetDirectDepends( const cmGeneratorTarget* target); - /** Get per-target generator information. */ - cmGeneratorTarget* GetGeneratorTarget(cmTarget const*) const; - - void AddGeneratorTarget(cmTarget* t, cmGeneratorTarget* gt) - { - this->GeneratorTargets[t] = gt; - } - const std::map<std::string, std::vector<cmLocalGenerator*> >& GetProjectMap() const {return this->ProjectMap;} @@ -353,15 +349,16 @@ public: void CreateEvaluationSourceFiles(std::string const& config) const; void SetFilenameTargetDepends(cmSourceFile* sf, - std::set<cmTarget const*> tgts); - std::set<cmTarget const*> const& + std::set<const cmGeneratorTarget*> tgts); + const std::set<const cmGeneratorTarget*>& GetFilenameTargetDepends(cmSourceFile* sf) const; #if defined(CMAKE_BUILD_WITH_CMAKE) cmFileLockPool& GetFileLockPool() { return FileLockPool; } #endif - bool GetConfigureDoneCMP0026() const { return this->ConfigureDoneCMP0026; } + bool GetConfigureDoneCMP0026() const + { return this->ConfigureDoneCMP0026AndCMP0024; } std::string MakeSilentFlag; protected: @@ -371,7 +368,7 @@ protected: void GetTargetSets(TargetDependSet& projectTargets, TargetDependSet& originalTargets, cmLocalGenerator* root, GeneratorVector const&); - bool IsRootOnlyTarget(cmTarget* target) const; + bool IsRootOnlyTarget(cmGeneratorTarget* target) const; void AddTargetDepends(const cmGeneratorTarget* target, TargetDependSet& projectTargets); void SetLanguageEnabledFlag(const std::string& l, cmMakefile* mf); @@ -384,7 +381,7 @@ protected: virtual bool CheckALLOW_DUPLICATE_CUSTOM_TARGETS() const; - std::vector<cmTarget const*> CreateQtAutoGeneratorsTargets(); + std::vector<const cmGeneratorTarget*> CreateQtAutoGeneratorsTargets(); std::string SelectMakeProgram(const std::string& makeProgram, const std::string& makeDefault = "") const; @@ -420,19 +417,14 @@ protected: std::map<std::string, cmExportBuildFileGenerator*> BuildExportSets; std::map<std::string, cmExportBuildFileGenerator*> BuildExportExportSets; - // All targets in the entire project. -#if defined(CMAKE_BUILD_WITH_CMAKE) -#ifdef CMake_HAVE_CXX11_UNORDERED_MAP - typedef std::unordered_map<std::string, cmTarget*> TargetMap; -#else - typedef cmsys::hash_map<std::string, cmTarget*> TargetMap; -#endif -#else - typedef std::map<std::string,cmTarget *> TargetMap; -#endif - TargetMap TotalTargets; - TargetMap AliasTargets; - TargetMap ImportedTargets; + std::map<std::string, std::string> AliasTargets; + + cmTarget* FindTargetImpl(std::string const& name) const; + cmTarget* FindImportedTargetImpl(std::string const& name) const; + + cmGeneratorTarget* FindGeneratorTargetImpl(std::string const& name) const; + cmGeneratorTarget* + FindImportedGeneratorTargetImpl(std::string const& name) const; const char* GetPredefinedTargetsFolder(); virtual bool UseFolderProperty(); @@ -457,7 +449,7 @@ private: void WriteRuleHashes(std::string const& pfile); void WriteSummary(); - void WriteSummary(cmTarget* target); + void WriteSummary(cmGeneratorTarget* target); void FinalizeTargetCompileInfo(); virtual void ForceLinkerLanguages(); @@ -467,6 +459,8 @@ private: void CheckCompilerIdCompatibility(cmMakefile* mf, std::string const& lang) const; + void ComputeBuildFileGenerators(); + cmExternalMakefileProjectGenerator* ExtraGenerator; // track files replaced during a Generate @@ -476,10 +470,10 @@ private: typedef std::map<cmGeneratorTarget const*, TargetDependSet> TargetDependMap; TargetDependMap TargetDependencies; - // Per-target generator information. - cmGeneratorTargetsType GeneratorTargets; friend class cmake; - void CreateGeneratorTargets(TargetTypes targetTypes, cmLocalGenerator* lg); + void CreateGeneratorTargets(TargetTypes targetTypes, cmMakefile* mf, + cmLocalGenerator* lg, + std::map<cmTarget*, cmGeneratorTarget*> const& importedMap); void CreateGeneratorTargets(TargetTypes targetTypes); void ClearGeneratorMembers(); @@ -504,7 +498,7 @@ private: // track targets to issue CMP0042 warning for. std::set<std::string> CMP0042WarnTargets; - mutable std::map<cmSourceFile*, std::set<cmTarget const*> > + mutable std::map<cmSourceFile*, std::set<cmGeneratorTarget const*> > FilenameTargetDepends; #if defined(CMAKE_BUILD_WITH_CMAKE) @@ -519,7 +513,7 @@ protected: bool ForceUnixPaths; bool ToolSupportsColor; bool InstallTargetEnabled; - bool ConfigureDoneCMP0026; + bool ConfigureDoneCMP0026AndCMP0024; }; #endif diff --git a/Source/cmGlobalGeneratorFactory.h b/Source/cmGlobalGeneratorFactory.h index ebba599..18d4324 100644 --- a/Source/cmGlobalGeneratorFactory.h +++ b/Source/cmGlobalGeneratorFactory.h @@ -38,6 +38,9 @@ public: /** Get the names of the current registered generators */ virtual void GetGenerators(std::vector<std::string>& names) const = 0; + + /** Determine whether or not this generator supports toolsets */ + virtual bool SupportsToolset() const = 0; }; template<class T> @@ -57,6 +60,9 @@ public: /** Get the names of the current registered generators */ virtual void GetGenerators(std::vector<std::string>& names) const { names.push_back(T::GetActualName()); } + + /** Determine whether or not this generator supports toolsets */ + virtual bool SupportsToolset() const { return T::SupportsToolset(); } }; #endif diff --git a/Source/cmGlobalGhsMultiGenerator.cxx b/Source/cmGlobalGhsMultiGenerator.cxx index 6dde1e3..1bcbd26 100644 --- a/Source/cmGlobalGhsMultiGenerator.cxx +++ b/Source/cmGlobalGhsMultiGenerator.cxx @@ -287,8 +287,8 @@ void cmGlobalGhsMultiGenerator::Generate() { cmLocalGhsMultiGenerator *lg = static_cast<cmLocalGhsMultiGenerator *>(this->LocalGenerators[i]); - cmGeneratorTargetsType tgts = lg->GetMakefile()->GetGeneratorTargets(); - this->UpdateBuildFiles(&tgts); + std::vector<cmGeneratorTarget*> tgts = lg->GetGeneratorTargets(); + this->UpdateBuildFiles(tgts); } } @@ -481,15 +481,15 @@ cmGlobalGhsMultiGenerator::GetFileNameFromPath(std::string const &path) } void cmGlobalGhsMultiGenerator::UpdateBuildFiles( - cmGeneratorTargetsType *tgts) + std::vector<cmGeneratorTarget*> tgts) { - for (cmGeneratorTargetsType::iterator tgtsI = tgts->begin(); - tgtsI != tgts->end(); ++tgtsI) + for (std::vector<cmGeneratorTarget*>::iterator tgtsI = tgts.begin(); + tgtsI != tgts.end(); ++tgtsI) { - const cmTarget *tgt(tgtsI->first); + const cmGeneratorTarget *tgt = *tgtsI; if (IsTgtForBuild(tgt)) { - char const *rawFolderName = tgtsI->first->GetProperty("FOLDER"); + char const *rawFolderName = tgt->GetProperty("FOLDER"); if (NULL == rawFolderName) { rawFolderName = ""; @@ -509,16 +509,17 @@ void cmGlobalGhsMultiGenerator::UpdateBuildFiles( splitPath.back()); *this->TargetFolderBuildStreams[folderName] << foldNameRelBuildFile << " "; - GhsMultiGpj::WriteGpjTag(cmGhsMultiTargetGenerator::GetGpjTag(tgt), + GhsMultiGpj::WriteGpjTag(cmGhsMultiTargetGenerator::GetGpjTag( + tgt), this->TargetFolderBuildStreams[folderName]); } } } -bool cmGlobalGhsMultiGenerator::IsTgtForBuild(const cmTarget *tgt) +bool cmGlobalGhsMultiGenerator::IsTgtForBuild(const cmGeneratorTarget *tgt) { const std::string config = - tgt->GetMakefile()->GetSafeDefinition("CMAKE_BUILD_TYPE"); + tgt->Target->GetMakefile()->GetSafeDefinition("CMAKE_BUILD_TYPE"); std::vector<cmSourceFile *> tgtSources; tgt->GetSourceFiles(tgtSources, config); bool tgtInBuild = true; diff --git a/Source/cmGlobalGhsMultiGenerator.h b/Source/cmGlobalGhsMultiGenerator.h index 8f88d4f..6f86c5d 100644 --- a/Source/cmGlobalGhsMultiGenerator.h +++ b/Source/cmGlobalGhsMultiGenerator.h @@ -35,6 +35,7 @@ public: /// @return the name of this generator. static std::string GetActualName() { return "Green Hills MULTI"; } + ///! Get the name for this generator virtual std::string GetName() const { return this->GetActualName(); } @@ -42,6 +43,12 @@ public: static void GetDocumentation(cmDocumentationEntry &entry); /** + * Utilized by the generator factory to determine if this generator + * supports toolsets. + */ + static bool SupportsToolset() { return false; } + + /** * Try to determine system information such as shared library * extension, pthreads, byte order etc. */ @@ -110,8 +117,8 @@ private: std::vector<cmsys::String>::const_iterator end, GhsMultiGpj::Types projType); static std::string GetFileNameFromPath(std::string const &path); - void UpdateBuildFiles(cmGeneratorTargetsType *tgts); - bool IsTgtForBuild(const cmTarget *tgt); + void UpdateBuildFiles(std::vector<cmGeneratorTarget*> tgts); + bool IsTgtForBuild(const cmGeneratorTarget *tgt); std::vector<cmGeneratedFileStream *> TargetSubProjects; std::map<std::string, cmGeneratedFileStream *> TargetFolderBuildStreams; diff --git a/Source/cmGlobalKdevelopGenerator.cxx b/Source/cmGlobalKdevelopGenerator.cxx index 138ddbb..018ab24 100644 --- a/Source/cmGlobalKdevelopGenerator.cxx +++ b/Source/cmGlobalKdevelopGenerator.cxx @@ -49,10 +49,9 @@ void cmGlobalKdevelopGenerator::Generate() it!= this->GlobalGenerator->GetProjectMap().end(); ++it) { - cmMakefile* mf = it->second[0]->GetMakefile(); - std::string outputDir=mf->GetCurrentBinaryDirectory(); - std::string projectDir=mf->GetHomeDirectory(); - std::string projectName=mf->GetProjectName(); + std::string outputDir=it->second[0]->GetCurrentBinaryDirectory(); + std::string projectDir=it->second[0]->GetSourceDirectory(); + std::string projectName=it->second[0]->GetProjectName(); std::string cmakeFilePattern("CMakeLists.txt;*.cmake;"); std::string fileToOpen; const std::vector<cmLocalGenerator*>& lgs= it->second; @@ -69,14 +68,14 @@ void cmGlobalKdevelopGenerator::Generate() for (std::vector<cmLocalGenerator*>::const_iterator lg=lgs.begin(); lg!=lgs.end(); lg++) { - cmMakefile* makefile=(*lg)->GetMakefile(); - cmGeneratorTargetsType const& targets = makefile->GetGeneratorTargets(); - for (cmGeneratorTargetsType::const_iterator ti = targets.begin(); - ti != targets.end(); ti++) + std::vector<cmGeneratorTarget*> const& targets = + (*lg)->GetGeneratorTargets(); + for (std::vector<cmGeneratorTarget*>::const_iterator ti = + targets.begin(); ti != targets.end(); ti++) { - if (ti->second->GetType()==cmTarget::EXECUTABLE) + if ((*ti)->GetType()==cmState::EXECUTABLE) { - executable = ti->second->GetLocation(""); + executable = (*ti)->GetLocation(""); break; } } @@ -106,6 +105,9 @@ bool cmGlobalKdevelopGenerator std::set<std::string> files; std::string tmp; + std::vector<std::string> hdrExts = + this->GlobalGenerator->GetCMakeInstance()->GetHeaderExtensions(); + for (std::vector<cmLocalGenerator*>::const_iterator it=lgs.begin(); it!=lgs.end(); it++) { @@ -134,12 +136,13 @@ bool cmGlobalKdevelopGenerator } //get all sources - cmTargets& targets=makefile->GetTargets(); - for (cmTargets::iterator ti = targets.begin(); + std::vector<cmGeneratorTarget*> targets=(*it)->GetGeneratorTargets(); + for (std::vector<cmGeneratorTarget*>::iterator ti = targets.begin(); ti != targets.end(); ti++) { std::vector<cmSourceFile*> sources; - ti->second.GetSourceFiles(sources, ti->second.GetMakefile() + cmGeneratorTarget* gt = *ti; + gt->GetSourceFiles(sources, gt->Target->GetMakefile() ->GetSafeDefinition("CMAKE_BUILD_TYPE")); for (std::vector<cmSourceFile*>::const_iterator si=sources.begin(); si!=sources.end(); si++) @@ -160,8 +163,7 @@ bool cmGlobalKdevelopGenerator // check if there's a matching header around for(std::vector<std::string>::const_iterator - ext = makefile->GetHeaderExtensions().begin(); - ext != makefile->GetHeaderExtensions().end(); ++ext) + ext = hdrExts.begin(); ext != hdrExts.end(); ++ext) { std::string hname=headerBasename; hname += "."; diff --git a/Source/cmGlobalNinjaGenerator.cxx b/Source/cmGlobalNinjaGenerator.cxx index 9d8193b..0f06e43 100644 --- a/Source/cmGlobalNinjaGenerator.cxx +++ b/Source/cmGlobalNinjaGenerator.cxx @@ -275,7 +275,7 @@ void cmGlobalNinjaGenerator::AddCustomCommandRule() /*deptype*/ "", /*rspfile*/ "", /*rspcontent*/ "", - /*restat*/ "1", + /*restat*/ "", // bound on each build statement as needed /*generator*/ false); } @@ -284,6 +284,7 @@ cmGlobalNinjaGenerator::WriteCustomCommandBuild(const std::string& command, const std::string& description, const std::string& comment, bool uses_terminal, + bool restat, const cmNinjaDeps& outputs, const cmNinjaDeps& deps, const cmNinjaDeps& orderOnly) @@ -300,6 +301,10 @@ cmGlobalNinjaGenerator::WriteCustomCommandBuild(const std::string& command, cmNinjaVars vars; vars["COMMAND"] = cmd; vars["DESC"] = EncodeLiteral(description); + if (restat) + { + vars["restat"] = "1"; + } if (uses_terminal && SupportsConsolePool()) { vars["pool"] = "console"; @@ -548,11 +553,11 @@ void cmGlobalNinjaGenerator::Generate() { // Check minimum Ninja version. if (cmSystemTools::VersionCompare(cmSystemTools::OP_LESS, - CurrentNinjaVersion().c_str(), + this->NinjaVersion.c_str(), RequiredNinjaVersion().c_str())) { std::ostringstream msg; - msg << "The detected version of Ninja (" << this->CurrentNinjaVersion(); + msg << "The detected version of Ninja (" << this->NinjaVersion; msg << ") is less than the version of Ninja required by CMake ("; msg << this->RequiredNinjaVersion() << ")."; this->GetCMakeInstance()->IssueMessage(cmake::FATAL_ERROR, msg.str()); @@ -585,6 +590,23 @@ void cmGlobalNinjaGenerator::Generate() this->CloseBuildFileStream(); } +void cmGlobalNinjaGenerator::FindMakeProgram(cmMakefile* mf) +{ + this->cmGlobalGenerator::FindMakeProgram(mf); + if (const char* ninjaCommand = mf->GetDefinition("CMAKE_MAKE_PROGRAM")) + { + this->NinjaCommand = ninjaCommand; + std::vector<std::string> command; + command.push_back(this->NinjaCommand); + command.push_back("--version"); + std::string version; + cmSystemTools::RunSingleCommand(command, + &version, 0, 0, 0, + cmSystemTools::OUTPUT_NONE); + this->NinjaVersion = cmSystemTools::TrimWhitespace(version); + } +} + void cmGlobalNinjaGenerator ::EnableLanguage(std::vector<std::string>const& langs, cmMakefile* mf, @@ -717,13 +739,11 @@ std::string cmGlobalNinjaGenerator::GetEditCacheCommand() const void cmGlobalNinjaGenerator ::ComputeTargetObjectDirectory(cmGeneratorTarget* gt) const { - cmTarget* target = gt->Target; - // Compute full path to object file directory for this target. std::string dir; - dir += gt->Makefile->GetCurrentBinaryDirectory(); + dir += gt->LocalGenerator->GetCurrentBinaryDirectory(); dir += "/"; - dir += gt->LocalGenerator->GetTargetDirectory(*target); + dir += gt->LocalGenerator->GetTargetDirectory(gt); dir += "/"; gt->ObjectDirectory = dir; } @@ -888,7 +908,7 @@ void cmGlobalNinjaGenerator::WriteDisclaimer(std::ostream& os) << cmVersion::GetMinorVersion() << "\n\n"; } -void cmGlobalNinjaGenerator::AddDependencyToAll(cmTarget* target) +void cmGlobalNinjaGenerator::AddDependencyToAll(cmGeneratorTarget* target) { this->AppendTargetOutputs(target, this->AllDependencies); } @@ -908,16 +928,17 @@ void cmGlobalNinjaGenerator::WriteAssumedSourceDependencies() WriteCustomCommandBuild(/*command=*/"", /*description=*/"", "Assume dependencies for generated source file.", /*uses_terminal*/false, + /*restat*/true, cmNinjaDeps(1, i->first), deps); } } void cmGlobalNinjaGenerator -::AppendTargetOutputs(cmTarget const* target, cmNinjaDeps& outputs) +::AppendTargetOutputs(cmGeneratorTarget const* target, cmNinjaDeps& outputs) { std::string configName = - target->GetMakefile()->GetSafeDefinition("CMAKE_BUILD_TYPE"); + target->Target->GetMakefile()->GetSafeDefinition("CMAKE_BUILD_TYPE"); // for frameworks, we want the real name, not smple name // frameworks always appear versioned, and the build.ninja @@ -926,20 +947,19 @@ cmGlobalNinjaGenerator bool realname = target->IsFrameworkOnApple(); switch (target->GetType()) { - case cmTarget::EXECUTABLE: - case cmTarget::SHARED_LIBRARY: - case cmTarget::STATIC_LIBRARY: - case cmTarget::MODULE_LIBRARY: + case cmState::EXECUTABLE: + case cmState::SHARED_LIBRARY: + case cmState::STATIC_LIBRARY: + case cmState::MODULE_LIBRARY: { - cmGeneratorTarget *gtgt = this->GetGeneratorTarget(target); outputs.push_back(this->ConvertToNinjaPath( - gtgt->GetFullPath(configName, false, realname))); + target->GetFullPath(configName, false, realname))); break; } - case cmTarget::OBJECT_LIBRARY: - case cmTarget::UTILITY: { + case cmState::OBJECT_LIBRARY: + case cmState::UTILITY: { std::string path = this->ConvertToNinjaPath( - target->GetMakefile()->GetCurrentBinaryDirectory()); + target->GetLocalGenerator()->GetCurrentBinaryDirectory()); if (path.empty() || path == ".") outputs.push_back(target->GetName()); else { @@ -950,7 +970,7 @@ cmGlobalNinjaGenerator break; } - case cmTarget::GLOBAL_TARGET: + case cmState::GLOBAL_TARGET: // Always use the target in HOME instead of an unused duplicate in a // subdirectory. outputs.push_back(target->GetName()); @@ -963,30 +983,29 @@ cmGlobalNinjaGenerator void cmGlobalNinjaGenerator -::AppendTargetDepends(cmTarget const* target, cmNinjaDeps& outputs) +::AppendTargetDepends(cmGeneratorTarget const* target, cmNinjaDeps& outputs) { - if (target->GetType() == cmTarget::GLOBAL_TARGET) { + if (target->GetType() == cmState::GLOBAL_TARGET) { // Global targets only depend on other utilities, which may not appear in // the TargetDepends set (e.g. "all"). std::set<std::string> const& utils = target->GetUtilities(); std::copy(utils.begin(), utils.end(), std::back_inserter(outputs)); } else { - cmGeneratorTarget* gt = this->GetGeneratorTarget(target); - cmTargetDependSet const& targetDeps = this->GetTargetDirectDepends(gt); + cmTargetDependSet const& targetDeps = this->GetTargetDirectDepends(target); for (cmTargetDependSet::const_iterator i = targetDeps.begin(); i != targetDeps.end(); ++i) { - if ((*i)->GetType() == cmTarget::INTERFACE_LIBRARY) + if ((*i)->GetType() == cmState::INTERFACE_LIBRARY) { continue; } - this->AppendTargetOutputs((*i)->Target, outputs); + this->AppendTargetOutputs(*i, outputs); } } } void cmGlobalNinjaGenerator::AddTargetAlias(const std::string& alias, - cmTarget* target) { + cmGeneratorTarget* target) { cmNinjaDeps outputs; this->AppendTargetOutputs(target, outputs); // Mark the target's outputs as ambiguous to ensure that no other target uses @@ -1198,16 +1217,15 @@ void cmGlobalNinjaGenerator::WriteTargetAll(std::ostream& os) void cmGlobalNinjaGenerator::WriteTargetRebuildManifest(std::ostream& os) { cmLocalGenerator *lg = this->LocalGenerators[0]; - cmMakefile* mfRoot = lg->GetMakefile(); std::ostringstream cmd; cmd << lg->ConvertToOutputFormat(cmSystemTools::GetCMakeCommand(), cmLocalGenerator::SHELL) << " -H" - << lg->ConvertToOutputFormat(mfRoot->GetHomeDirectory(), + << lg->ConvertToOutputFormat(lg->GetSourceDirectory(), cmLocalGenerator::SHELL) << " -B" - << lg->ConvertToOutputFormat(mfRoot->GetHomeOutputDirectory(), + << lg->ConvertToOutputFormat(lg->GetBinaryDirectory(), cmLocalGenerator::SHELL); WriteRule(*this->RulesFileStream, "RERUN_CMAKE", @@ -1265,28 +1283,16 @@ std::string cmGlobalNinjaGenerator::ninjaCmd() const { cmLocalGenerator* lgen = this->LocalGenerators[0]; if (lgen) { - return lgen->ConvertToOutputFormat( - lgen->GetMakefile()->GetRequiredDefinition("CMAKE_MAKE_PROGRAM"), - cmLocalGenerator::SHELL); + return lgen->ConvertToOutputFormat(this->NinjaCommand, + cmLocalGenerator::SHELL); } return "ninja"; } -std::string cmGlobalNinjaGenerator::CurrentNinjaVersion() const -{ - std::string version; - std::string command = ninjaCmd() + " --version"; - cmSystemTools::RunSingleCommand(command.c_str(), - &version, 0, 0, 0, - cmSystemTools::OUTPUT_NONE); - - return cmSystemTools::TrimWhitespace(version); -} - bool cmGlobalNinjaGenerator::SupportsConsolePool() const { return cmSystemTools::VersionCompare(cmSystemTools::OP_LESS, - CurrentNinjaVersion().c_str(), + this->NinjaVersion.c_str(), RequiredNinjaVersionForConsolePool().c_str()) == false; } diff --git a/Source/cmGlobalNinjaGenerator.h b/Source/cmGlobalNinjaGenerator.h index 292f7c7..8656590 100644 --- a/Source/cmGlobalNinjaGenerator.h +++ b/Source/cmGlobalNinjaGenerator.h @@ -74,6 +74,12 @@ public: static void WriteComment(std::ostream& os, const std::string& comment); /** + * Utilized by the generator factory to determine if this generator + * supports toolsets. + */ + static bool SupportsToolset() { return false; } + + /** * Write a build statement to @a os with the @a comment using * the @a rule the list of @a outputs files and inputs. * It also writes the variables bound to this build statement. @@ -106,6 +112,7 @@ public: const std::string& description, const std::string& comment, bool uses_terminal, + bool restat, const cmNinjaDeps& outputs, const cmNinjaDeps& deps = cmNinjaDeps(), const cmNinjaDeps& orderOnly = cmNinjaDeps()); @@ -285,9 +292,11 @@ public: ASD.insert(deps.begin(), deps.end()); } - void AppendTargetOutputs(cmTarget const* target, cmNinjaDeps& outputs); - void AppendTargetDepends(cmTarget const* target, cmNinjaDeps& outputs); - void AddDependencyToAll(cmTarget* target); + void AppendTargetOutputs(cmGeneratorTarget const* target, + cmNinjaDeps& outputs); + void AppendTargetDepends(cmGeneratorTarget const* target, + cmNinjaDeps& outputs); + void AddDependencyToAll(cmGeneratorTarget* target); void AddDependencyToAll(const std::string& input); const std::vector<cmLocalGenerator*>& GetLocalGenerators() const { @@ -299,11 +308,10 @@ public: int GetRuleCmdLength(const std::string& name) { return RuleCmdLength[name]; } - void AddTargetAlias(const std::string& alias, cmTarget* target); + void AddTargetAlias(const std::string& alias, cmGeneratorTarget* target); virtual void ComputeTargetObjectDirectory(cmGeneratorTarget* gt) const; - std::string CurrentNinjaVersion() const; // Ninja generator uses 'deps' and 'msvc_deps_prefix' introduced in 1.3 static std::string RequiredNinjaVersion() { return "1.3"; } static std::string RequiredNinjaVersionForConsolePool() { return "1.5"; } @@ -318,7 +326,7 @@ protected: private: virtual std::string GetEditCacheCommand() const; - + virtual void FindMakeProgram(cmMakefile* mf); void OpenBuildFileStream(); void CloseBuildFileStream(); @@ -388,8 +396,11 @@ private: /// The mapping from source file to assumed dependencies. std::map<std::string, std::set<std::string> > AssumedSourceDependencies; - typedef std::map<std::string, cmTarget*> TargetAliasMap; + typedef std::map<std::string, cmGeneratorTarget*> TargetAliasMap; TargetAliasMap TargetAliases; + + std::string NinjaCommand; + std::string NinjaVersion; }; #endif // ! cmGlobalNinjaGenerator_h diff --git a/Source/cmGlobalUnixMakefileGenerator3.cxx b/Source/cmGlobalUnixMakefileGenerator3.cxx index 0064713..ce7815d 100644 --- a/Source/cmGlobalUnixMakefileGenerator3.cxx +++ b/Source/cmGlobalUnixMakefileGenerator3.cxx @@ -15,8 +15,6 @@ #include "cmMakefile.h" #include "cmake.h" #include "cmGeneratedFileStream.h" -#include "cmSourceFile.h" -#include "cmTarget.h" #include "cmGeneratorTarget.h" #include "cmAlgorithms.h" @@ -114,13 +112,11 @@ void cmGlobalUnixMakefileGenerator3 ::ComputeTargetObjectDirectory(cmGeneratorTarget* gt) const { - cmTarget* target = gt->Target; - // Compute full path to object file directory for this target. std::string dir; - dir += gt->Makefile->GetCurrentBinaryDirectory(); + dir += gt->LocalGenerator->GetCurrentBinaryDirectory(); dir += "/"; - dir += gt->LocalGenerator->GetTargetDirectory(*target); + dir += gt->LocalGenerator->GetTargetDirectory(gt); dir += "/"; gt->ObjectDirectory = dir; } @@ -161,9 +157,8 @@ void cmGlobalUnixMakefileGenerator3::Generate() } for(unsigned int i = 0; i < this->LocalGenerators.size(); ++i) { - cmLocalUnixMakefileGenerator3 *lg = - static_cast<cmLocalUnixMakefileGenerator3 *>(this->LocalGenerators[i]); - std::string markFileName = lg->GetMakefile()->GetCurrentBinaryDirectory(); + cmLocalGenerator *lg = this->LocalGenerators[i]; + std::string markFileName = lg->GetCurrentBinaryDirectory(); markFileName += "/"; markFileName += cmake::GetCMakeFilesDirectory(); markFileName += "/progress.marks"; @@ -395,7 +390,7 @@ void cmGlobalUnixMakefileGenerator3::WriteMainCMakefile() { lg = static_cast<cmLocalUnixMakefileGenerator3 *>(this->LocalGenerators[i]); - tmpStr = lg->GetMakefile()->GetCurrentBinaryDirectory(); + tmpStr = lg->GetCurrentBinaryDirectory(); tmpStr += cmake::GetCMakeFilesDirectory(); tmpStr += "/CMakeDirectoryInformation.cmake"; cmakefileStream << " \"" << @@ -425,17 +420,19 @@ void cmGlobalUnixMakefileGenerator3 { lg = static_cast<cmLocalUnixMakefileGenerator3 *>(lGenerators[i]); // for all of out targets - for (cmTargets::iterator l = lg->GetMakefile()->GetTargets().begin(); - l != lg->GetMakefile()->GetTargets().end(); l++) + std::vector<cmGeneratorTarget*> tgts = lg->GetGeneratorTargets(); + for (std::vector<cmGeneratorTarget*>::iterator l = tgts.begin(); + l != tgts.end(); l++) { - if((l->second.GetType() == cmTarget::EXECUTABLE) || - (l->second.GetType() == cmTarget::STATIC_LIBRARY) || - (l->second.GetType() == cmTarget::SHARED_LIBRARY) || - (l->second.GetType() == cmTarget::MODULE_LIBRARY) || - (l->second.GetType() == cmTarget::OBJECT_LIBRARY) || - (l->second.GetType() == cmTarget::UTILITY)) + if(((*l)->GetType() == cmState::EXECUTABLE) || + ((*l)->GetType() == cmState::STATIC_LIBRARY) || + ((*l)->GetType() == cmState::SHARED_LIBRARY) || + ((*l)->GetType() == cmState::MODULE_LIBRARY) || + ((*l)->GetType() == cmState::OBJECT_LIBRARY) || + ((*l)->GetType() == cmState::UTILITY)) { - std::string tname = lg->GetRelativeTargetDirectory(l->second); + cmGeneratorTarget* gt = *l; + std::string tname = lg->GetRelativeTargetDirectory(gt); tname += "/DependInfo.cmake"; cmSystemTools::ConvertToUnixSlashes(tname); cmakefileStream << " \"" << tname << "\"\n"; @@ -454,37 +451,33 @@ cmGlobalUnixMakefileGenerator3 bool check_relink) { // Get the relative path to the subdirectory from the top. - std::string makeTarget = lg->GetMakefile()->GetCurrentBinaryDirectory(); + std::string makeTarget = lg->GetCurrentBinaryDirectory(); makeTarget += "/"; makeTarget += pass; // The directory-level rule should depend on the target-level rules // for all targets in the directory. std::vector<std::string> depends; - cmGeneratorTargetsType targets = lg->GetMakefile()->GetGeneratorTargets(); - for(cmGeneratorTargetsType::iterator l = targets.begin(); + std::vector<cmGeneratorTarget*> targets = lg->GetGeneratorTargets(); + for(std::vector<cmGeneratorTarget*>::iterator l = targets.begin(); l != targets.end(); ++l) { - cmGeneratorTarget* gtarget = l->second; + cmGeneratorTarget* gtarget = *l; int type = gtarget->GetType(); - if((type == cmTarget::EXECUTABLE) || - (type == cmTarget::STATIC_LIBRARY) || - (type == cmTarget::SHARED_LIBRARY) || - (type == cmTarget::MODULE_LIBRARY) || - (type == cmTarget::OBJECT_LIBRARY) || - (type == cmTarget::UTILITY)) + if((type == cmState::EXECUTABLE) || + (type == cmState::STATIC_LIBRARY) || + (type == cmState::SHARED_LIBRARY) || + (type == cmState::MODULE_LIBRARY) || + (type == cmState::OBJECT_LIBRARY) || + (type == cmState::UTILITY)) { - if(gtarget->Target->IsImported()) - { - continue; - } // Add this to the list of depends rules in this directory. if((!check_all || !gtarget->GetPropertyAsBool("EXCLUDE_FROM_ALL")) && (!check_relink || gtarget ->NeedRelinkBeforeInstall(lg->GetConfigName()))) { - std::string tname = lg->GetRelativeTargetDirectory(*gtarget->Target); + std::string tname = lg->GetRelativeTargetDirectory(gtarget); tname += "/"; tname += pass; depends.push_back(tname); @@ -495,7 +488,7 @@ cmGlobalUnixMakefileGenerator3 // The directory-level rule should depend on the directory-level // rules of the subdirectories. std::vector<cmState::Snapshot> children - = lg->GetMakefile()->GetStateSnapshot().GetChildren(); + = lg->GetStateSnapshot().GetChildren(); for(std::vector<cmState::Snapshot>::const_iterator ci = children.begin(); ci != children.end(); ++ci) { @@ -528,13 +521,13 @@ cmGlobalUnixMakefileGenerator3 cmLocalUnixMakefileGenerator3* lg) { // Only subdirectories need these rules. - if(lg->GetMakefile()->IsRootMakefile()) + if(lg->IsRootMakefile()) { return; } // Begin the directory-level rules section. - std::string dir = lg->GetMakefile()->GetCurrentBinaryDirectory(); + std::string dir = lg->GetCurrentBinaryDirectory(); dir = lg->Convert(dir, cmLocalGenerator::HOME_OUTPUT, cmLocalGenerator::MAKERULE); lg->WriteDivider(ruleFileStream); @@ -585,12 +578,12 @@ void cmGlobalUnixMakefileGenerator3 else { cmState::Snapshot snapshot = this->CMakeInstance->GetCurrentSnapshot(); - mf = new cmMakefile(this, snapshot); - // set the Start directories - mf->SetCurrentSourceDirectory + snapshot.GetDirectory().SetCurrentSource (this->CMakeInstance->GetHomeDirectory()); - mf->SetCurrentBinaryDirectory + snapshot.GetDirectory().SetCurrentBinary (this->CMakeInstance->GetHomeOutputDirectory()); + snapshot.SetDefaultDefinitions(); + mf = new cmMakefile(this, snapshot); } std::string tname = targetName; @@ -628,15 +621,11 @@ cmGlobalUnixMakefileGenerator3 lg = static_cast<cmLocalUnixMakefileGenerator3 *> (this->LocalGenerators[i]); // for each target Generate the rule files for each target. - cmGeneratorTargetsType targets = lg->GetMakefile()->GetGeneratorTargets(); - for(cmGeneratorTargetsType::iterator t = targets.begin(); + std::vector<cmGeneratorTarget*> targets = lg->GetGeneratorTargets(); + for(std::vector<cmGeneratorTarget*>::iterator t = targets.begin(); t != targets.end(); ++t) { - cmGeneratorTarget* gtarget = t->second; - if(gtarget->Target->IsImported()) - { - continue; - } + cmGeneratorTarget* gtarget = *t; // Don't emit the same rule twice (e.g. two targets with the same // simple name) int type = gtarget->GetType(); @@ -645,12 +634,12 @@ cmGlobalUnixMakefileGenerator3 emitted.insert(name).second && // Handle user targets here. Global targets are handled in // the local generator on a per-directory basis. - ((type == cmTarget::EXECUTABLE) || - (type == cmTarget::STATIC_LIBRARY) || - (type == cmTarget::SHARED_LIBRARY) || - (type == cmTarget::MODULE_LIBRARY) || - (type == cmTarget::OBJECT_LIBRARY) || - (type == cmTarget::UTILITY))) + ((type == cmState::EXECUTABLE) || + (type == cmState::STATIC_LIBRARY) || + (type == cmState::SHARED_LIBRARY) || + (type == cmState::MODULE_LIBRARY) || + (type == cmState::OBJECT_LIBRARY) || + (type == cmState::UTILITY))) { // Add a rule to build the target by name. lg->WriteDivider(ruleFileStream); @@ -673,7 +662,7 @@ cmGlobalUnixMakefileGenerator3 // Add a fast rule to build the target std::string localName = - lg->GetRelativeTargetDirectory(*gtarget->Target); + lg->GetRelativeTargetDirectory(gtarget); std::string makefileName; makefileName = localName; makefileName += "/build.make"; @@ -693,7 +682,7 @@ cmGlobalUnixMakefileGenerator3 if(gtarget ->NeedRelinkBeforeInstall(lg->GetConfigName())) { - makeTargetName = lg->GetRelativeTargetDirectory(*gtarget->Target); + makeTargetName = lg->GetRelativeTargetDirectory(gtarget); makeTargetName += "/preinstall"; localName = name; localName += "/preinstall"; @@ -729,32 +718,28 @@ cmGlobalUnixMakefileGenerator3 depends.push_back("cmake_check_build_system"); // for each target Generate the rule files for each target. - cmGeneratorTargetsType targets = lg->GetMakefile()->GetGeneratorTargets(); - for(cmGeneratorTargetsType::iterator t = targets.begin(); + std::vector<cmGeneratorTarget*> targets = lg->GetGeneratorTargets(); + for(std::vector<cmGeneratorTarget*>::iterator t = targets.begin(); t != targets.end(); ++t) { - cmGeneratorTarget* gtarget = t->second; - if(gtarget->Target->IsImported()) - { - continue; - } + cmGeneratorTarget* gtarget = *t; int type = gtarget->GetType(); std::string name = gtarget->GetName(); if (!name.empty() - && ( (type == cmTarget::EXECUTABLE) - || (type == cmTarget::STATIC_LIBRARY) - || (type == cmTarget::SHARED_LIBRARY) - || (type == cmTarget::MODULE_LIBRARY) - || (type == cmTarget::OBJECT_LIBRARY) - || (type == cmTarget::UTILITY))) + && ( (type == cmState::EXECUTABLE) + || (type == cmState::STATIC_LIBRARY) + || (type == cmState::SHARED_LIBRARY) + || (type == cmState::MODULE_LIBRARY) + || (type == cmState::OBJECT_LIBRARY) + || (type == cmState::UTILITY))) { std::string makefileName; // Add a rule to build the target by name. - localName = lg->GetRelativeTargetDirectory(*gtarget->Target); + localName = lg->GetRelativeTargetDirectory(gtarget); makefileName = localName; makefileName += "/build.make"; - bool needRequiresStep = this->NeedRequiresStep(*gtarget->Target); + bool needRequiresStep = this->NeedRequiresStep(gtarget); lg->WriteDivider(ruleFileStream); ruleFileStream @@ -785,13 +770,13 @@ cmGlobalUnixMakefileGenerator3 depends.clear(); cmLocalUnixMakefileGenerator3::EchoProgress progress; - progress.Dir = lg->GetMakefile()->GetHomeOutputDirectory(); + progress.Dir = lg->GetBinaryDirectory(); progress.Dir += cmake::GetCMakeFilesDirectory(); { std::ostringstream progressArg; const char* sep = ""; std::vector<unsigned long>& progFiles = - this->ProgressMap[gtarget->Target].Marks; + this->ProgressMap[gtarget].Marks; for (std::vector<unsigned long>::iterator i = progFiles.begin(); i != progFiles.end(); ++i) { @@ -861,7 +846,7 @@ cmGlobalUnixMakefileGenerator3 } depends.clear(); depends.push_back("cmake_check_build_system"); - localName = lg->GetRelativeTargetDirectory(*gtarget->Target); + localName = lg->GetRelativeTargetDirectory(gtarget); localName += "/rule"; lg->WriteMakeRule(ruleFileStream, "Build rule for subdir invocation for target.", @@ -878,7 +863,7 @@ cmGlobalUnixMakefileGenerator3 if(gtarget ->NeedRelinkBeforeInstall(lg->GetConfigName())) { - localName = lg->GetRelativeTargetDirectory(*gtarget->Target); + localName = lg->GetRelativeTargetDirectory(gtarget); localName += "/preinstall"; depends.clear(); commands.clear(); @@ -899,7 +884,7 @@ cmGlobalUnixMakefileGenerator3 } // add the clean rule - localName = lg->GetRelativeTargetDirectory(*gtarget->Target); + localName = lg->GetRelativeTargetDirectory(gtarget); makeTargetName = localName; makeTargetName += "/clean"; depends.clear(); @@ -927,18 +912,16 @@ void cmGlobalUnixMakefileGenerator3::InitializeProgressMarks() lgi != this->LocalGenerators.end(); ++lgi) { cmLocalGenerator* lg = *lgi; - cmMakefile* mf = lg->GetMakefile(); - cmTargets const& targets = mf->GetTargets(); - for(cmTargets::const_iterator t = targets.begin(); t != targets.end(); ++t) + std::vector<cmGeneratorTarget*> targets = lg->GetGeneratorTargets(); + for(std::vector<cmGeneratorTarget*>::const_iterator t = targets.begin(); + t != targets.end(); ++t) { - cmTarget const& target = t->second; - - cmGeneratorTarget* gt = this->GetGeneratorTarget(&target); + cmGeneratorTarget* gt = *t; cmLocalGenerator* tlg = gt->GetLocalGenerator(); - if(gt->GetType() == cmTarget::INTERFACE_LIBRARY - || gt->Target->GetPropertyAsBool("EXCLUDE_FROM_ALL")) + if(gt->GetType() == cmState::INTERFACE_LIBRARY + || gt->GetPropertyAsBool("EXCLUDE_FROM_ALL")) { continue; } @@ -979,12 +962,12 @@ cmGlobalUnixMakefileGenerator3 size_t count = 0; if(emitted.insert(target).second) { - count = this->ProgressMap[target->Target].Marks.size(); + count = this->ProgressMap[target].Marks.size(); TargetDependSet const& depends = this->GetTargetDirectDepends(target); for(TargetDependSet::const_iterator di = depends.begin(); di != depends.end(); ++di) { - if ((*di)->GetType() == cmTarget::INTERFACE_LIBRARY) + if ((*di)->GetType() == cmState::INTERFACE_LIBRARY) { continue; } @@ -997,7 +980,7 @@ cmGlobalUnixMakefileGenerator3 //---------------------------------------------------------------------------- size_t cmGlobalUnixMakefileGenerator3 -::CountProgressMarksInAll(cmLocalUnixMakefileGenerator3* lg) +::CountProgressMarksInAll(cmLocalGenerator* lg) { size_t count = 0; std::set<cmGeneratorTarget const*> emitted; @@ -1016,7 +999,7 @@ void cmGlobalUnixMakefileGenerator3::RecordTargetProgress( cmMakefileTargetGenerator* tg) { - TargetProgress& tp = this->ProgressMap[tg->GetTarget()]; + TargetProgress& tp = this->ProgressMap[tg->GetGeneratorTarget()]; tp.NumberOfActions = tg->GetNumberOfProgressActions(); tp.VariableFile = tg->GetProgressFileNameFull(); } @@ -1060,13 +1043,14 @@ cmGlobalUnixMakefileGenerator3 { // Create the target-level dependency. cmGeneratorTarget const* dep = *i; - if (dep->GetType() == cmTarget::INTERFACE_LIBRARY) + if (dep->GetType() == cmState::INTERFACE_LIBRARY) { continue; } cmLocalUnixMakefileGenerator3* lg3 = static_cast<cmLocalUnixMakefileGenerator3*>(dep->GetLocalGenerator()); - std::string tgtName = lg3->GetRelativeTargetDirectory(*(*dep).Target); + std::string tgtName = + lg3->GetRelativeTargetDirectory(const_cast<cmGeneratorTarget*>(dep)); tgtName += "/all"; depends.push_back(tgtName); } @@ -1098,23 +1082,24 @@ void cmGlobalUnixMakefileGenerator3::WriteHelpRule static_cast<cmLocalUnixMakefileGenerator3 *>(this->LocalGenerators[i]); // for the passed in makefile or if this is the top Makefile wripte out // the targets - if (lg2 == lg || lg->GetMakefile()->IsRootMakefile()) + if (lg2 == lg || lg->IsRootMakefile()) { // for each target Generate the rule files for each target. - cmTargets& targets = lg2->GetMakefile()->GetTargets(); - for(cmTargets::iterator t = targets.begin(); t != targets.end(); ++t) + std::vector<cmGeneratorTarget*> targets = lg2->GetGeneratorTargets(); + for(std::vector<cmGeneratorTarget*>::iterator t = targets.begin(); + t != targets.end(); ++t) { - cmTarget const& target = t->second; - cmTarget::TargetType type = target.GetType(); - if((type == cmTarget::EXECUTABLE) || - (type == cmTarget::STATIC_LIBRARY) || - (type == cmTarget::SHARED_LIBRARY) || - (type == cmTarget::MODULE_LIBRARY) || - (type == cmTarget::OBJECT_LIBRARY) || - (type == cmTarget::GLOBAL_TARGET) || - (type == cmTarget::UTILITY)) + cmGeneratorTarget* target = *t; + cmState::TargetType type = target->GetType(); + if((type == cmState::EXECUTABLE) || + (type == cmState::STATIC_LIBRARY) || + (type == cmState::SHARED_LIBRARY) || + (type == cmState::MODULE_LIBRARY) || + (type == cmState::OBJECT_LIBRARY) || + (type == cmState::GLOBAL_TARGET) || + (type == cmState::UTILITY)) { - std::string name = target.GetName(); + std::string name = target->GetName(); if(emittedTargets.insert(name).second) { path = "... "; @@ -1141,19 +1126,19 @@ void cmGlobalUnixMakefileGenerator3::WriteHelpRule bool cmGlobalUnixMakefileGenerator3 -::NeedRequiresStep(cmTarget const& target) +::NeedRequiresStep(const cmGeneratorTarget* target) { std::set<std::string> languages; - cmGeneratorTarget* gtgt = this->GetGeneratorTarget(&target); - gtgt->GetLanguages(languages, - target.GetMakefile()->GetSafeDefinition("CMAKE_BUILD_TYPE")); + target->GetLanguages(languages, + target->Target->GetMakefile() + ->GetSafeDefinition("CMAKE_BUILD_TYPE")); for(std::set<std::string>::const_iterator l = languages.begin(); l != languages.end(); ++l) { std::string var = "CMAKE_NEEDS_REQUIRES_STEP_"; var += *l; var += "_FLAG"; - if(target.GetMakefile()->GetDefinition(var)) + if(target->Target->GetMakefile()->GetDefinition(var)) { return true; } diff --git a/Source/cmGlobalUnixMakefileGenerator3.h b/Source/cmGlobalUnixMakefileGenerator3.h index 5f39c79..0591a5a 100644 --- a/Source/cmGlobalUnixMakefileGenerator3.h +++ b/Source/cmGlobalUnixMakefileGenerator3.h @@ -64,6 +64,12 @@ public: return cmGlobalUnixMakefileGenerator3::GetActualName();} static std::string GetActualName() {return "Unix Makefiles";} + /** + * Utilized by the generator factory to determine if this generator + * supports toolsets. + */ + static bool SupportsToolset() { return false; } + /** Get the documentation entry for this generator. */ static void GetDocumentation(cmDocumentationEntry& entry); @@ -154,7 +160,7 @@ protected: cmGeneratorTarget* target); // does this generator need a requires step for any of its targets - bool NeedRequiresStep(cmTarget const&); + bool NeedRequiresStep(cmGeneratorTarget const*); // Target name hooks for superclass. const char* GetAllTargetName() const { return "all"; } @@ -192,13 +198,13 @@ protected: std::vector<unsigned long> Marks; void WriteProgressVariables(unsigned long total, unsigned long& current); }; - typedef std::map<cmTarget const*, TargetProgress, - cmStrictTargetComparison> ProgressMapType; + typedef std::map<cmGeneratorTarget const*, TargetProgress, + cmGeneratorTarget::StrictTargetComparison> ProgressMapType; ProgressMapType ProgressMap; size_t CountProgressMarksInTarget(cmGeneratorTarget const* target, std::set<cmGeneratorTarget const*>& emitted); - size_t CountProgressMarksInAll(cmLocalUnixMakefileGenerator3* lg); + size_t CountProgressMarksInAll(cmLocalGenerator* lg); cmGeneratedFileStream *CommandDatabase; private: diff --git a/Source/cmGlobalVisualStudio10Generator.cxx b/Source/cmGlobalVisualStudio10Generator.cxx index 59e8f8c..c49008d 100644 --- a/Source/cmGlobalVisualStudio10Generator.cxx +++ b/Source/cmGlobalVisualStudio10Generator.cxx @@ -81,6 +81,8 @@ public: names.push_back(vs10generatorName + std::string(" IA64")); names.push_back(vs10generatorName + std::string(" Win64")); } + + virtual bool SupportsToolset() const { return true; } }; //---------------------------------------------------------------------------- @@ -325,23 +327,13 @@ cmLocalGenerator* cmGlobalVisualStudio10Generator::CreateLocalGenerator( return new cmLocalVisualStudio10Generator(this, mf); } -//---------------------------------------------------------------------------- -bool cmGlobalVisualStudio10Generator::Compute() -{ - if (!cmGlobalVisualStudio8Generator::Compute()) - { - return false; - } - this->LongestSource = LongestSourcePath(); - return true; -} - void cmGlobalVisualStudio10Generator::Generate() { + this->LongestSource = LongestSourcePath(); this->cmGlobalVisualStudio8Generator::Generate(); if(this->LongestSource.Length > 0) { - cmMakefile* mf = this->LongestSource.Target->GetMakefile(); + cmLocalGenerator* lg = this->LongestSource.Target->GetLocalGenerator(); std::ostringstream e; e << "The binary and/or source directory paths may be too long to generate " @@ -356,13 +348,13 @@ void cmGlobalVisualStudio10Generator::Generate() " " << this->LongestSource.SourceFile->GetFullPath() << "\n" "This is because some Visual Studio tools would append the relative " "path to the end of the referencing directory path, as in:\n" - " " << mf->GetCurrentBinaryDirectory() << "/" + " " << lg->GetCurrentBinaryDirectory() << "/" << this->LongestSource.SourceRel << "\n" "and then incorrectly complain that the file does not exist because " "the path length is too long for some internal buffer or API. " "To avoid this problem CMake must use a full path for this file " "which then triggers the VS 10 property dialog bug."; - mf->IssueMessage(cmake::WARNING, e.str().c_str()); + lg->IssueMessage(cmake::WARNING, e.str().c_str()); } } @@ -601,9 +593,11 @@ cmGlobalVisualStudio10Generator //---------------------------------------------------------------------------- void cmGlobalVisualStudio10Generator::PathTooLong( - cmTarget* target, cmSourceFile const* sf, std::string const& sfRel) + cmGeneratorTarget *target, cmSourceFile const* sf, + std::string const& sfRel) { - size_t len = (strlen(target->GetMakefile()->GetCurrentBinaryDirectory()) + + size_t len = + (strlen(target->GetLocalGenerator()->GetCurrentBinaryDirectory()) + 1 + sfRel.length()); if(len > this->LongestSource.Length) { diff --git a/Source/cmGlobalVisualStudio10Generator.h b/Source/cmGlobalVisualStudio10Generator.h index f4861dc..6bf4740 100644 --- a/Source/cmGlobalVisualStudio10Generator.h +++ b/Source/cmGlobalVisualStudio10Generator.h @@ -45,8 +45,6 @@ public: std::vector<std::string> const& makeOptions = std::vector<std::string>() ); - virtual bool Compute(); - ///! create the correct local generator virtual cmLocalGenerator *CreateLocalGenerator(cmMakefile* mf); @@ -97,7 +95,7 @@ public: /** Generate an <output>.rule file path for a given command output. */ virtual std::string GenerateRuleFile(std::string const& output) const; - void PathTooLong(cmTarget* target, cmSourceFile const* sf, + void PathTooLong(cmGeneratorTarget* target, cmSourceFile const* sf, std::string const& sfRel); virtual const char* GetToolsVersion() { return "4.0"; } @@ -141,7 +139,7 @@ private: { LongestSourcePath(): Length(0), Target(0), SourceFile(0) {} size_t Length; - cmTarget* Target; + cmGeneratorTarget* Target; cmSourceFile const* SourceFile; std::string SourceRel; }; diff --git a/Source/cmGlobalVisualStudio11Generator.cxx b/Source/cmGlobalVisualStudio11Generator.cxx index 419bf8a..9522f6e 100644 --- a/Source/cmGlobalVisualStudio11Generator.cxx +++ b/Source/cmGlobalVisualStudio11Generator.cxx @@ -96,6 +96,8 @@ public: names.push_back(std::string(vs11generatorName) + " " + *i); } } + + virtual bool SupportsToolset() const { return true; } }; //---------------------------------------------------------------------------- @@ -278,10 +280,10 @@ cmGlobalVisualStudio11Generator::GetInstalledWindowsCESDKs() //---------------------------------------------------------------------------- bool -cmGlobalVisualStudio11Generator::NeedsDeploy(cmTarget::TargetType type) const +cmGlobalVisualStudio11Generator::NeedsDeploy(cmState::TargetType type) const { - if((type == cmTarget::EXECUTABLE || - type == cmTarget::SHARED_LIBRARY) && + if((type == cmState::EXECUTABLE || + type == cmState::SHARED_LIBRARY) && (this->SystemIsWindowsPhone || this->SystemIsWindowsStore)) { diff --git a/Source/cmGlobalVisualStudio11Generator.h b/Source/cmGlobalVisualStudio11Generator.h index 9499d80..f3f6b2b 100644 --- a/Source/cmGlobalVisualStudio11Generator.h +++ b/Source/cmGlobalVisualStudio11Generator.h @@ -48,7 +48,7 @@ protected: static std::set<std::string> GetInstalledWindowsCESDKs(); /** Return true if the configuration needs to be deployed */ - virtual bool NeedsDeploy(cmTarget::TargetType type) const; + virtual bool NeedsDeploy(cmState::TargetType type) const; private: class Factory; friend class Factory; diff --git a/Source/cmGlobalVisualStudio12Generator.cxx b/Source/cmGlobalVisualStudio12Generator.cxx index efa1133..568d4d7 100644 --- a/Source/cmGlobalVisualStudio12Generator.cxx +++ b/Source/cmGlobalVisualStudio12Generator.cxx @@ -76,6 +76,8 @@ public: names.push_back(vs12generatorName + std::string(" ARM")); names.push_back(vs12generatorName + std::string(" Win64")); } + + virtual bool SupportsToolset() const { return true; } }; //---------------------------------------------------------------------------- diff --git a/Source/cmGlobalVisualStudio14Generator.cxx b/Source/cmGlobalVisualStudio14Generator.cxx index 41825fb..a05ac24 100644 --- a/Source/cmGlobalVisualStudio14Generator.cxx +++ b/Source/cmGlobalVisualStudio14Generator.cxx @@ -76,6 +76,8 @@ public: names.push_back(vs14generatorName + std::string(" ARM")); names.push_back(vs14generatorName + std::string(" Win64")); } + + virtual bool SupportsToolset() const { return true; } }; //---------------------------------------------------------------------------- diff --git a/Source/cmGlobalVisualStudio6Generator.cxx b/Source/cmGlobalVisualStudio6Generator.cxx index 14de698..5866c0e 100644 --- a/Source/cmGlobalVisualStudio6Generator.cxx +++ b/Source/cmGlobalVisualStudio6Generator.cxx @@ -223,8 +223,8 @@ void cmGlobalVisualStudio6Generator tt = orderedProjectTargets.begin(); tt != orderedProjectTargets.end(); ++tt) { - cmTarget const* target = (*tt)->Target; - if(target->GetType() == cmTarget::INTERFACE_LIBRARY) + cmGeneratorTarget const* target = *tt; + if(target->GetType() == cmState::INTERFACE_LIBRARY) { continue; } @@ -235,14 +235,15 @@ void cmGlobalVisualStudio6Generator std::string project = target->GetName(); std::string location = expath; this->WriteExternalProject(fout, project.c_str(), - location.c_str(), target->GetUtilities()); + location.c_str(), target->GetUtilities()); } else { std::string dspname = GetVS6TargetName(target->GetName()); - std::string dir = target->GetMakefile()->GetCurrentBinaryDirectory(); + std::string dir = + target->GetLocalGenerator()->GetCurrentBinaryDirectory(); dir = root->Convert(dir.c_str(), cmLocalGenerator::START_OUTPUT); - this->WriteProject(fout, dspname.c_str(), dir.c_str(), *target); + this->WriteProject(fout, dspname.c_str(), dir.c_str(), target); } } @@ -260,7 +261,7 @@ void cmGlobalVisualStudio6Generator } std::string fname = root->GetMakefile()->GetCurrentBinaryDirectory(); fname += "/"; - fname += root->GetMakefile()->GetProjectName(); + fname += root->GetProjectName(); fname += ".dsw"; cmsys::ofstream fout(fname.c_str()); if(!fout) @@ -287,9 +288,9 @@ void cmGlobalVisualStudio6Generator::OutputDSWFile() // Note, that dependencies from executables to // the libraries it uses are also done here void cmGlobalVisualStudio6Generator::WriteProject(std::ostream& fout, - const std::string& dspname, - const char* dir, - cmTarget const& target) + const std::string& dspname, + const char* dir, + const cmGeneratorTarget *target) { fout << "#########################################################" "######################\n\n"; @@ -298,7 +299,7 @@ void cmGlobalVisualStudio6Generator::WriteProject(std::ostream& fout, fout << "Package=<5>\n{{{\n}}}\n\n"; fout << "Package=<4>\n"; fout << "{{{\n"; - VSDependSet const& depends = this->VSTargetDepends[&target]; + VSDependSet const& depends = this->VSTargetDepends[target]; for(VSDependSet::const_iterator di = depends.begin(); di != depends.end(); ++di) { @@ -309,7 +310,7 @@ void cmGlobalVisualStudio6Generator::WriteProject(std::ostream& fout, } fout << "}}}\n\n"; - UtilityDependsMap::iterator ui = this->UtilityDepends.find(&target); + UtilityDependsMap::iterator ui = this->UtilityDepends.find(target); if(ui != this->UtilityDepends.end()) { const char* uname = ui->second.c_str(); @@ -382,12 +383,14 @@ void cmGlobalVisualStudio6Generator::WriteDSWHeader(std::ostream& fout) //---------------------------------------------------------------------------- std::string -cmGlobalVisualStudio6Generator::WriteUtilityDepend(cmTarget const* target) +cmGlobalVisualStudio6Generator::WriteUtilityDepend( + const cmGeneratorTarget *target) { std::string pname = target->GetName(); pname += "_UTILITY"; pname = GetVS6TargetName(pname.c_str()); - std::string fname = target->GetMakefile()->GetCurrentBinaryDirectory(); + std::string fname = + target->GetLocalGenerator()->GetCurrentBinaryDirectory(); fname += "/"; fname += pname; fname += ".dsp"; diff --git a/Source/cmGlobalVisualStudio6Generator.h b/Source/cmGlobalVisualStudio6Generator.h index e9b24ea..ae2988e 100644 --- a/Source/cmGlobalVisualStudio6Generator.h +++ b/Source/cmGlobalVisualStudio6Generator.h @@ -15,8 +15,6 @@ #include "cmGlobalVisualStudioGenerator.h" #include "cmGlobalGeneratorFactory.h" -class cmTarget; - /** \class cmGlobalVisualStudio6Generator * \brief Write a Unix makefiles. * @@ -38,6 +36,12 @@ public: /** Get the documentation entry for this generator. */ static void GetDocumentation(cmDocumentationEntry& entry); + /** + * Utilized by the generator factory to determine if this generator + * supports toolsets. + */ + static bool SupportsToolset() { return false; } + ///! Create a local generator appropriate to this Global Generator virtual cmLocalGenerator *CreateLocalGenerator(cmMakefile* mf); @@ -94,12 +98,12 @@ private: void WriteDSWHeader(std::ostream& fout); void WriteProject(std::ostream& fout, const std::string& name, const char* path, - cmTarget const& t); + cmGeneratorTarget const* t); void WriteExternalProject(std::ostream& fout, const std::string& name, const char* path, const std::set<std::string>& dependencies); void WriteDSWFooter(std::ostream& fout); - virtual std::string WriteUtilityDepend(cmTarget const* target); + virtual std::string WriteUtilityDepend(const cmGeneratorTarget *target); std::string MSDevCommand; bool MSDevCommandInitialized; std::string const& GetMSDevCommand(); diff --git a/Source/cmGlobalVisualStudio71Generator.cxx b/Source/cmGlobalVisualStudio71Generator.cxx index b913afc..8227b82 100644 --- a/Source/cmGlobalVisualStudio71Generator.cxx +++ b/Source/cmGlobalVisualStudio71Generator.cxx @@ -152,7 +152,7 @@ void cmGlobalVisualStudio71Generator::WriteProject(std::ostream& fout, const std::string& dspname, const char* dir, - cmTarget const& t) + cmGeneratorTarget const* t) { // check to see if this is a fortran build const char* ext = ".vcproj"; @@ -163,7 +163,7 @@ cmGlobalVisualStudio71Generator::WriteProject(std::ostream& fout, ext = ".vfproj"; project = "Project(\"{6989167D-11E4-40FE-8C1A-2192A86A7E90}\") = \""; } - const char* targetExt = t.GetProperty("GENERATOR_FILE_NAME_EXT"); + const char* targetExt = t->GetProperty("GENERATOR_FILE_NAME_EXT"); if(targetExt) { ext = targetExt; @@ -180,7 +180,7 @@ cmGlobalVisualStudio71Generator::WriteProject(std::ostream& fout, fout <<"EndProject\n"; - UtilityDependsMap::iterator ui = this->UtilityDepends.find(&t); + UtilityDependsMap::iterator ui = this->UtilityDepends.find(t); if(ui != this->UtilityDepends.end()) { const char* uname = ui->second.c_str(); @@ -204,9 +204,9 @@ void cmGlobalVisualStudio71Generator ::WriteProjectDepends(std::ostream& fout, const std::string&, - const char*, cmTarget const& target) + const char*, cmGeneratorTarget const* target) { - VSDependSet const& depends = this->VSTargetDepends[&target]; + VSDependSet const& depends = this->VSTargetDepends[target]; for(VSDependSet::const_iterator di = depends.begin(); di != depends.end(); ++di) { @@ -215,7 +215,7 @@ cmGlobalVisualStudio71Generator if(guid.empty()) { std::string m = "Target: "; - m += target.GetName(); + m += target->GetName(); m += " depends on unknown target: "; m += name; cmSystemTools::Error(m.c_str()); @@ -272,7 +272,7 @@ void cmGlobalVisualStudio71Generator // executables to the libraries it uses are also done here void cmGlobalVisualStudio71Generator ::WriteProjectConfigurations( - std::ostream& fout, const std::string& name, cmTarget::TargetType, + std::ostream& fout, const std::string& name, cmState::TargetType, std::vector<std::string> const& configs, const std::set<std::string>& configsPartOfDefaultBuild, std::string const& platformMapping) diff --git a/Source/cmGlobalVisualStudio71Generator.h b/Source/cmGlobalVisualStudio71Generator.h index fbb9ecc..5035fda 100644 --- a/Source/cmGlobalVisualStudio71Generator.h +++ b/Source/cmGlobalVisualStudio71Generator.h @@ -59,12 +59,12 @@ protected: std::ostream& fout, std::vector<std::string> const& configs); virtual void WriteProject(std::ostream& fout, const std::string& name, const char* path, - cmTarget const& t); + const cmGeneratorTarget *t); virtual void WriteProjectDepends(std::ostream& fout, const std::string& name, const char* path, - cmTarget const& t); + cmGeneratorTarget const* t); virtual void WriteProjectConfigurations( - std::ostream& fout, const std::string& name, cmTarget::TargetType type, + std::ostream& fout, const std::string& name, cmState::TargetType type, std::vector<std::string> const& configs, const std::set<std::string>& configsPartOfDefaultBuild, const std::string& platformMapping = ""); diff --git a/Source/cmGlobalVisualStudio7Generator.cxx b/Source/cmGlobalVisualStudio7Generator.cxx index 05da022..f5848ab 100644 --- a/Source/cmGlobalVisualStudio7Generator.cxx +++ b/Source/cmGlobalVisualStudio7Generator.cxx @@ -362,10 +362,10 @@ void cmGlobalVisualStudio7Generator { return; } - this->CurrentProject = root->GetMakefile()->GetProjectName(); - std::string fname = root->GetMakefile()->GetCurrentBinaryDirectory(); + this->CurrentProject = root->GetProjectName(); + std::string fname = root->GetCurrentBinaryDirectory(); fname += "/"; - fname += root->GetMakefile()->GetProjectName(); + fname += root->GetProjectName(); fname += ".sln"; cmGeneratedFileStream fout(fname.c_str()); fout.SetCopyIfDifferent(true); @@ -401,8 +401,8 @@ void cmGlobalVisualStudio7Generator::WriteTargetConfigurations( for(OrderedTargetDependSet::const_iterator tt = projectTargets.begin(); tt != projectTargets.end(); ++tt) { - cmTarget const* target = (*tt)->Target; - if(target->GetType() == cmTarget::INTERFACE_LIBRARY) + cmGeneratorTarget const* target = *tt; + if(target->GetType() == cmState::INTERFACE_LIBRARY) { continue; } @@ -441,8 +441,8 @@ void cmGlobalVisualStudio7Generator::WriteTargetsToSolution( for(OrderedTargetDependSet::const_iterator tt = projectTargets.begin(); tt != projectTargets.end(); ++tt) { - cmTarget const* target = (*tt)->Target; - if(target->GetType() == cmTarget::INTERFACE_LIBRARY) + cmGeneratorTarget const* target = *tt; + if(target->GetType() == cmState::INTERFACE_LIBRARY) { continue; } @@ -468,8 +468,8 @@ void cmGlobalVisualStudio7Generator::WriteTargetsToSolution( target->GetProperty("GENERATOR_FILE_NAME"); if(vcprojName) { - cmMakefile* tmf = target->GetMakefile(); - std::string dir = tmf->GetCurrentBinaryDirectory(); + cmLocalGenerator* lg = target->GetLocalGenerator(); + std::string dir = lg->GetCurrentBinaryDirectory(); dir = root->Convert(dir.c_str(), cmLocalGenerator::START_OUTPUT); if(dir == ".") @@ -477,7 +477,7 @@ void cmGlobalVisualStudio7Generator::WriteTargetsToSolution( dir = ""; // msbuild cannot handle ".\" prefix } this->WriteProject(fout, vcprojName, dir.c_str(), - *target); + target); written = true; } } @@ -533,19 +533,19 @@ void cmGlobalVisualStudio7Generator::WriteTargetDepends( for(OrderedTargetDependSet::const_iterator tt = projectTargets.begin(); tt != projectTargets.end(); ++tt) { - cmTarget const* target = (*tt)->Target; - if(target->GetType() == cmTarget::INTERFACE_LIBRARY) + cmGeneratorTarget const* target = *tt; + if(target->GetType() == cmState::INTERFACE_LIBRARY) { continue; } - cmMakefile* mf = target->GetMakefile(); const char *vcprojName = target->GetProperty("GENERATOR_FILE_NAME"); if (vcprojName) { - std::string dir = mf->GetCurrentSourceDirectory(); + std::string dir = target->GetLocalGenerator() + ->GetCurrentSourceDirectory(); this->WriteProjectDepends(fout, vcprojName, - dir.c_str(), *target); + dir.c_str(), target); } } } @@ -685,7 +685,8 @@ cmGlobalVisualStudio7Generator::ConvertToSolutionPath(const char* path) // the libraries it uses are also done here void cmGlobalVisualStudio7Generator::WriteProject(std::ostream& fout, const std::string& dspname, - const char* dir, cmTarget const& target) + const char* dir, + cmGeneratorTarget const* target) { // check to see if this is a fortran build const char* ext = ".vcproj"; @@ -703,7 +704,7 @@ void cmGlobalVisualStudio7Generator::WriteProject(std::ostream& fout, << dspname << ext << "\", \"{" << this->GetGUID(dspname) << "}\"\nEndProject\n"; - UtilityDependsMap::iterator ui = this->UtilityDepends.find(&target); + UtilityDependsMap::iterator ui = this->UtilityDepends.find(target); if(ui != this->UtilityDepends.end()) { const char* uname = ui->second.c_str(); @@ -725,11 +726,11 @@ void cmGlobalVisualStudio7Generator ::WriteProjectDepends(std::ostream& fout, const std::string& dspname, - const char*, cmTarget const& target) + const char*, cmGeneratorTarget const* target) { int depcount = 0; std::string dspguid = this->GetGUID(dspname); - VSDependSet const& depends = this->VSTargetDepends[&target]; + VSDependSet const& depends = this->VSTargetDepends[target]; for(VSDependSet::const_iterator di = depends.begin(); di != depends.end(); ++di) { @@ -738,7 +739,7 @@ cmGlobalVisualStudio7Generator if(guid.empty()) { std::string m = "Target: "; - m += target.GetName(); + m += target->GetName(); m += " depends on unknown target: "; m += name; cmSystemTools::Error(m.c_str()); @@ -747,7 +748,7 @@ cmGlobalVisualStudio7Generator depcount++; } - UtilityDependsMap::iterator ui = this->UtilityDepends.find(&target); + UtilityDependsMap::iterator ui = this->UtilityDepends.find(target); if(ui != this->UtilityDepends.end()) { const char* uname = ui->second.c_str(); @@ -760,7 +761,7 @@ cmGlobalVisualStudio7Generator // executables to the libraries it uses are also done here void cmGlobalVisualStudio7Generator ::WriteProjectConfigurations( - std::ostream& fout, const std::string& name, cmTarget::TargetType, + std::ostream& fout, const std::string& name, cmState::TargetType, std::vector<std::string> const& configs, const std::set<std::string>& configsPartOfDefaultBuild, const std::string& platformMapping) @@ -887,13 +888,14 @@ void cmGlobalVisualStudio7Generator::WriteSLNHeader(std::ostream& fout) //---------------------------------------------------------------------------- std::string -cmGlobalVisualStudio7Generator::WriteUtilityDepend(cmTarget const* target) +cmGlobalVisualStudio7Generator::WriteUtilityDepend( + cmGeneratorTarget const* target) { std::vector<std::string> configs; - target->GetMakefile()->GetConfigurations(configs); + target->Target->GetMakefile()->GetConfigurations(configs); std::string pname = target->GetName(); pname += "_UTILITY"; - std::string fname = target->GetMakefile()->GetCurrentBinaryDirectory(); + std::string fname = target->GetLocalGenerator()->GetCurrentBinaryDirectory(); fname += "/"; fname += pname; fname += ".vcproj"; @@ -994,13 +996,14 @@ cmGlobalVisualStudio7Generator std::set<std::string> cmGlobalVisualStudio7Generator::IsPartOfDefaultBuild( std::vector<std::string> const& configs, - OrderedTargetDependSet const& projectTargets, cmTarget const* target) + OrderedTargetDependSet const& projectTargets, + cmGeneratorTarget const* target) { std::set<std::string> activeConfigs; // if it is a utilitiy target then only make it part of the // default build if another target depends on it int type = target->GetType(); - if (type == cmTarget::GLOBAL_TARGET) + if (type == cmState::GLOBAL_TARGET) { // check if INSTALL target is part of default build if(target->GetName() == "INSTALL") @@ -1009,12 +1012,13 @@ cmGlobalVisualStudio7Generator::IsPartOfDefaultBuild( for(std::vector<std::string>::const_iterator i = configs.begin(); i != configs.end(); ++i) { - const char* propertyValue = target->GetMakefile() + const char* propertyValue = target->Target->GetMakefile() ->GetDefinition("CMAKE_VS_INCLUDE_INSTALL_TO_DEFAULT_BUILD"); cmGeneratorExpression ge; cmsys::auto_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(propertyValue); - if(cmSystemTools::IsOn(cge->Evaluate(target->GetMakefile(), *i))) + if(cmSystemTools::IsOn(cge->Evaluate(target->GetLocalGenerator(), + *i))) { activeConfigs.insert(*i); } @@ -1022,17 +1026,16 @@ cmGlobalVisualStudio7Generator::IsPartOfDefaultBuild( } return activeConfigs; } - if(type == cmTarget::UTILITY && !this->IsDependedOn(projectTargets, target)) + if(type == cmState::UTILITY && !this->IsDependedOn(projectTargets, target)) { return activeConfigs; } - cmGeneratorTarget* gt = this->GetGeneratorTarget(target); // inspect EXCLUDE_FROM_DEFAULT_BUILD[_<CONFIG>] properties for(std::vector<std::string>::const_iterator i = configs.begin(); i != configs.end(); ++i) { const char* propertyValue = - gt->GetFeature("EXCLUDE_FROM_DEFAULT_BUILD", i->c_str()); + target->GetFeature("EXCLUDE_FROM_DEFAULT_BUILD", i->c_str()); if(cmSystemTools::IsOff(propertyValue)) { activeConfigs.insert(*i); @@ -1044,9 +1047,8 @@ cmGlobalVisualStudio7Generator::IsPartOfDefaultBuild( bool cmGlobalVisualStudio7Generator ::IsDependedOn(OrderedTargetDependSet const& projectTargets, - cmTarget const* targetIn) + cmGeneratorTarget const* gtIn) { - cmGeneratorTarget* gtIn = this->GetGeneratorTarget(targetIn); for (OrderedTargetDependSet::const_iterator l = projectTargets.begin(); l != projectTargets.end(); ++l) { diff --git a/Source/cmGlobalVisualStudio7Generator.h b/Source/cmGlobalVisualStudio7Generator.h index 35575d1..de2d35e 100644 --- a/Source/cmGlobalVisualStudio7Generator.h +++ b/Source/cmGlobalVisualStudio7Generator.h @@ -53,6 +53,12 @@ public: static void GetDocumentation(cmDocumentationEntry& entry); /** + * Utilized by the generator factory to determine if this generator + * supports toolsets. + */ + static bool SupportsToolset() { return false; } + + /** * Try to determine system information such as shared library * extension, pthreads, byte order etc. */ @@ -94,7 +100,8 @@ public: /** Return true if the target project file should have the option LinkLibraryDependencies and link to .sln dependencies. */ - virtual bool NeedLinkLibraryDependencies(cmTarget&) { return false; } + virtual bool NeedLinkLibraryDependencies(cmGeneratorTarget*) + { return false; } const char* GetIntelProjectVersion(); @@ -123,12 +130,12 @@ protected: std::vector<cmLocalGenerator*>& generators); virtual void WriteProject(std::ostream& fout, const std::string& name, const char* path, - cmTarget const& t); + const cmGeneratorTarget *t); virtual void WriteProjectDepends(std::ostream& fout, const std::string& name, const char* path, - cmTarget const&t); + cmGeneratorTarget const* t); virtual void WriteProjectConfigurations( - std::ostream& fout, const std::string& name, cmTarget::TargetType type, + std::ostream& fout, const std::string& name, cmState::TargetType type, std::vector<std::string> const& configs, const std::set<std::string>& configsPartOfDefaultBuild, const std::string& platformMapping = ""); @@ -136,7 +143,7 @@ protected: cmLocalGenerator* root); virtual void WriteSLNFooter(std::ostream& fout); virtual void WriteSLNHeader(std::ostream& fout); - virtual std::string WriteUtilityDepend(cmTarget const* target); + virtual std::string WriteUtilityDepend(const cmGeneratorTarget *target); virtual void WriteTargetsToSolution( std::ostream& fout, @@ -162,9 +169,9 @@ protected: std::set<std::string> IsPartOfDefaultBuild(std::vector<std::string> const& configs, OrderedTargetDependSet const& projectTargets, - cmTarget const* target); + cmGeneratorTarget const* target); bool IsDependedOn(OrderedTargetDependSet const& projectTargets, - cmTarget const* target); + cmGeneratorTarget const* target); std::map<std::string, std::string> GUIDMap; virtual void WriteFolders(std::ostream& fout); diff --git a/Source/cmGlobalVisualStudio8Generator.cxx b/Source/cmGlobalVisualStudio8Generator.cxx index 70c00e9..3abff6c 100644 --- a/Source/cmGlobalVisualStudio8Generator.cxx +++ b/Source/cmGlobalVisualStudio8Generator.cxx @@ -84,6 +84,8 @@ public: names.push_back("Visual Studio 8 2005 " + *i); } } + + virtual bool SupportsToolset() const { return false; } }; //---------------------------------------------------------------------------- @@ -256,7 +258,7 @@ bool cmGlobalVisualStudio8Generator::AddCheckTarget() noCommandLines); cmGeneratorTarget* gt = new cmGeneratorTarget(tgt, lg); - mf->AddGeneratorTarget(tgt, gt); + lg->AddGeneratorTarget(gt); // Organize in the "predefined targets" folder: // @@ -312,10 +314,10 @@ bool cmGlobalVisualStudio8Generator::AddCheckTarget() cmCustomCommandLine commandLine; commandLine.push_back(cmSystemTools::GetCMakeCommand()); std::string argH = "-H"; - argH += mf->GetHomeDirectory(); + argH += lg->GetSourceDirectory(); commandLine.push_back(argH); std::string argB = "-B"; - argB += mf->GetHomeOutputDirectory(); + argB += lg->GetBinaryDirectory(); commandLine.push_back(argB); commandLine.push_back("--check-stamp-list"); commandLine.push_back(stampList.c_str()); @@ -336,7 +338,7 @@ bool cmGlobalVisualStudio8Generator::AddCheckTarget() no_main_dependency, commandLines, "Checking Build System", no_working_directory, true)) { - tgt->AddSource(file->GetFullPath()); + gt->AddSource(file->GetFullPath()); } else { @@ -348,27 +350,26 @@ bool cmGlobalVisualStudio8Generator::AddCheckTarget() } //---------------------------------------------------------------------------- -bool cmGlobalVisualStudio8Generator::Compute() +void cmGlobalVisualStudio8Generator::AddExtraIDETargets() { - if (!cmGlobalVisualStudio7Generator::Compute()) - { - return false; - } - + cmGlobalVisualStudio7Generator::AddExtraIDETargets(); if(this->AddCheckTarget()) { - // All targets depend on the build-system check target. - for(TargetMap::const_iterator - ti = this->TotalTargets.begin(); - ti != this->TotalTargets.end(); ++ti) + for (unsigned int i = 0; i < this->LocalGenerators.size(); ++i) { - if(ti->first != CMAKE_CHECK_BUILD_SYSTEM_TARGET) + std::vector<cmGeneratorTarget*> tgts = + this->LocalGenerators[i]->GetGeneratorTargets(); + // All targets depend on the build-system check target. + for(std::vector<cmGeneratorTarget*>::iterator ti = tgts.begin(); + ti != tgts.end(); ++ti) { - ti->second->AddUtility(CMAKE_CHECK_BUILD_SYSTEM_TARGET); + if((*ti)->GetName() != CMAKE_CHECK_BUILD_SYSTEM_TARGET) + { + (*ti)->Target->AddUtility(CMAKE_CHECK_BUILD_SYSTEM_TARGET); + } } } } - return true; } //---------------------------------------------------------------------------- @@ -391,7 +392,7 @@ cmGlobalVisualStudio8Generator void cmGlobalVisualStudio8Generator ::WriteProjectConfigurations( - std::ostream& fout, const std::string& name, cmTarget::TargetType type, + std::ostream& fout, const std::string& name, cmState::TargetType type, std::vector<std::string> const& configs, const std::set<std::string>& configsPartOfDefaultBuild, std::string const& platformMapping) @@ -428,10 +429,10 @@ cmGlobalVisualStudio8Generator //---------------------------------------------------------------------------- bool -cmGlobalVisualStudio8Generator::NeedsDeploy(cmTarget::TargetType type) const +cmGlobalVisualStudio8Generator::NeedsDeploy(cmState::TargetType type) const { - bool needsDeploy = (type == cmTarget::EXECUTABLE || - type == cmTarget::SHARED_LIBRARY); + bool needsDeploy = (type == cmState::EXECUTABLE || + type == cmState::SHARED_LIBRARY); return this->TargetsWindowsCE() && needsDeploy; } @@ -445,15 +446,15 @@ bool cmGlobalVisualStudio8Generator::ComputeTargetDepends() //---------------------------------------------------------------------------- void cmGlobalVisualStudio8Generator::WriteProjectDepends( - std::ostream& fout, const std::string&, const char*, cmTarget const& t) + std::ostream& fout, const std::string&, const char*, + cmGeneratorTarget const* gt) { - cmGeneratorTarget* gt = this->GetGeneratorTarget(&t); TargetDependSet const& unordered = this->GetTargetDirectDepends(gt); OrderedTargetDependSet depends(unordered, std::string()); for(OrderedTargetDependSet::const_iterator i = depends.begin(); i != depends.end(); ++i) { - if((*i)->GetType() == cmTarget::INTERFACE_LIBRARY) + if((*i)->GetType() == cmState::INTERFACE_LIBRARY) { continue; } @@ -464,16 +465,17 @@ void cmGlobalVisualStudio8Generator::WriteProjectDepends( //---------------------------------------------------------------------------- bool cmGlobalVisualStudio8Generator::NeedLinkLibraryDependencies( - cmTarget& target) + cmGeneratorTarget *target) { // Look for utility dependencies that magically link. for(std::set<std::string>::const_iterator ui = - target.GetUtilities().begin(); - ui != target.GetUtilities().end(); ++ui) + target->GetUtilities().begin(); + ui != target->GetUtilities().end(); ++ui) { - if(cmTarget* depTarget = this->FindTarget(ui->c_str())) + if(cmGeneratorTarget* depTarget = + target->GetLocalGenerator()->FindGeneratorTargetToUse(ui->c_str())) { - if(depTarget->GetType() != cmTarget::INTERFACE_LIBRARY + if(depTarget->GetType() != cmState::INTERFACE_LIBRARY && depTarget->GetProperty("EXTERNAL_MSPROJECT")) { // This utility dependency names an external .vcproj target. diff --git a/Source/cmGlobalVisualStudio8Generator.h b/Source/cmGlobalVisualStudio8Generator.h index 1c61103..b3093cc 100644 --- a/Source/cmGlobalVisualStudio8Generator.h +++ b/Source/cmGlobalVisualStudio8Generator.h @@ -60,14 +60,14 @@ public: /** Return true if the target project file should have the option LinkLibraryDependencies and link to .sln dependencies. */ - virtual bool NeedLinkLibraryDependencies(cmTarget& target); + virtual bool NeedLinkLibraryDependencies(cmGeneratorTarget* target); /** Return true if building for Windows CE */ virtual bool TargetsWindowsCE() const { return !this->WindowsCEVersion.empty(); } protected: - virtual bool Compute(); + virtual void AddExtraIDETargets(); virtual const char* GetIDEVersion() { return "8.0"; } virtual std::string FindDevEnvCommand(); @@ -77,21 +77,22 @@ protected: bool AddCheckTarget(); /** Return true if the configuration needs to be deployed */ - virtual bool NeedsDeploy(cmTarget::TargetType type) const; + virtual bool NeedsDeploy(cmState::TargetType type) const; static cmIDEFlagTable const* GetExtraFlagTableVS8(); virtual void WriteSLNHeader(std::ostream& fout); virtual void WriteSolutionConfigurations( std::ostream& fout, std::vector<std::string> const& configs); virtual void WriteProjectConfigurations( - std::ostream& fout, const std::string& name, cmTarget::TargetType type, + std::ostream& fout, const std::string& name, cmState::TargetType type, std::vector<std::string> const& configs, const std::set<std::string>& configsPartOfDefaultBuild, const std::string& platformMapping = ""); virtual bool ComputeTargetDepends(); virtual void WriteProjectDepends(std::ostream& fout, const std::string& name, - const char* path, cmTarget const& t); + const char* path, + const cmGeneratorTarget *t); std::string Name; std::string WindowsCEVersion; diff --git a/Source/cmGlobalVisualStudio9Generator.cxx b/Source/cmGlobalVisualStudio9Generator.cxx index d98793a..884f754 100644 --- a/Source/cmGlobalVisualStudio9Generator.cxx +++ b/Source/cmGlobalVisualStudio9Generator.cxx @@ -88,6 +88,8 @@ public: names.push_back("Visual Studio 9 2008 " + *i); } } + + virtual bool SupportsToolset() const { return false; } }; //---------------------------------------------------------------------------- diff --git a/Source/cmGlobalVisualStudioGenerator.cxx b/Source/cmGlobalVisualStudioGenerator.cxx index 7552d67..6a1aa29 100644 --- a/Source/cmGlobalVisualStudioGenerator.cxx +++ b/Source/cmGlobalVisualStudioGenerator.cxx @@ -64,13 +64,8 @@ std::string cmGlobalVisualStudioGenerator::GetRegistryBase( } //---------------------------------------------------------------------------- -bool cmGlobalVisualStudioGenerator::Compute() +void cmGlobalVisualStudioGenerator::AddExtraIDETargets() { - if (!cmGlobalGenerator::Compute()) - { - return false; - } - // Add a special target that depends on ALL projects for easy build // of one configuration only. const char* no_working_dir = 0; @@ -92,7 +87,7 @@ bool cmGlobalVisualStudioGenerator::Compute() "Build all projects"); cmGeneratorTarget* gt = new cmGeneratorTarget(allBuild, gen[0]); - allBuild->GetMakefile()->AddGeneratorTarget(allBuild, gt); + gen[0]->AddGeneratorTarget(gt); #if 0 // Can't activate this code because we want ALL_BUILD @@ -112,19 +107,20 @@ bool cmGlobalVisualStudioGenerator::Compute() for(std::vector<cmLocalGenerator*>::iterator i = gen.begin(); i != gen.end(); ++i) { - cmGeneratorTargetsType targets = - (*i)->GetMakefile()->GetGeneratorTargets(); - for(cmGeneratorTargetsType::iterator t = targets.begin(); + std::vector<cmGeneratorTarget*> targets = + (*i)->GetGeneratorTargets(); + for(std::vector<cmGeneratorTarget*>::iterator t = targets.begin(); t != targets.end(); ++t) { - if (t->second->GetType() == cmTarget::GLOBAL_TARGET - || t->first->IsImported()) + cmGeneratorTarget* tgt = *t; + if (tgt->GetType() == cmState::GLOBAL_TARGET + || tgt->IsImported()) { continue; } - if(!this->IsExcluded(gen[0], t->second)) + if(!this->IsExcluded(gen[0], tgt)) { - allBuild->AddUtility(t->second->GetName()); + allBuild->AddUtility(tgt->GetName()); } } } @@ -144,16 +140,15 @@ bool cmGlobalVisualStudioGenerator::Compute() static_cast<cmLocalVisualStudioGenerator*>(*lgi); lg->AddCMakeListsRules(); } - return true; } //---------------------------------------------------------------------------- void cmGlobalVisualStudioGenerator ::ComputeTargetObjectDirectory(cmGeneratorTarget* gt) const { - std::string dir = gt->Makefile->GetCurrentBinaryDirectory(); + std::string dir = gt->LocalGenerator->GetCurrentBinaryDirectory(); dir += "/"; - std::string tgtDir = gt->LocalGenerator->GetTargetDirectory(*gt->Target); + std::string tgtDir = gt->LocalGenerator->GetTargetDirectory(gt); if(!tgtDir.empty()) { dir += tgtDir; @@ -256,7 +251,7 @@ cmGlobalVisualStudioGenerator { topLevelSlnName = mf->GetCurrentBinaryDirectory(); topLevelSlnName += "/"; - topLevelSlnName += mf->GetProjectName(); + topLevelSlnName += this->LocalGenerators[0]->GetProjectName(); topLevelSlnName += ".sln"; } @@ -307,19 +302,20 @@ std::string cmGlobalVisualStudioGenerator::GetUserMacrosRegKeyBase() } //---------------------------------------------------------------------------- -void cmGlobalVisualStudioGenerator::FillLinkClosure(cmTarget const* target, - TargetSet& linked) +void cmGlobalVisualStudioGenerator::FillLinkClosure( + const cmGeneratorTarget *target, + TargetSet& linked) { if(linked.insert(target).second) { - cmGeneratorTarget* gt = this->GetGeneratorTarget(target); - TargetDependSet const& depends = this->GetTargetDirectDepends(gt); + TargetDependSet const& depends = + this->GetTargetDirectDepends(target); for(TargetDependSet::const_iterator di = depends.begin(); di != depends.end(); ++di) { if(di->IsLink()) { - this->FillLinkClosure((*di)->Target, linked); + this->FillLinkClosure(*di, linked); } } } @@ -327,7 +323,7 @@ void cmGlobalVisualStudioGenerator::FillLinkClosure(cmTarget const* target, //---------------------------------------------------------------------------- cmGlobalVisualStudioGenerator::TargetSet const& -cmGlobalVisualStudioGenerator::GetTargetLinkClosure(cmTarget* target) +cmGlobalVisualStudioGenerator::GetTargetLinkClosure(cmGeneratorTarget* target) { TargetSetMap::iterator i = this->TargetLinkClosure.find(target); if(i == this->TargetLinkClosure.end()) @@ -341,25 +337,25 @@ cmGlobalVisualStudioGenerator::GetTargetLinkClosure(cmTarget* target) //---------------------------------------------------------------------------- void cmGlobalVisualStudioGenerator::FollowLinkDepends( - cmTarget const* target, std::set<cmTarget const*>& linked) + const cmGeneratorTarget *target, + std::set<const cmGeneratorTarget *> &linked) { - if(target->GetType() == cmTarget::INTERFACE_LIBRARY) + if(target->GetType() == cmState::INTERFACE_LIBRARY) { return; } if(linked.insert(target).second && - target->GetType() == cmTarget::STATIC_LIBRARY) + target->GetType() == cmState::STATIC_LIBRARY) { // Static library targets do not list their link dependencies so // we must follow them transitively now. - cmGeneratorTarget* gt = this->GetGeneratorTarget(target); - TargetDependSet const& depends = this->GetTargetDirectDepends(gt); + TargetDependSet const& depends = this->GetTargetDirectDepends(target); for(TargetDependSet::const_iterator di = depends.begin(); di != depends.end(); ++di) { if(di->IsLink()) { - this->FollowLinkDepends((*di)->Target, linked); + this->FollowLinkDepends(*di, linked); } } } @@ -379,11 +375,11 @@ bool cmGlobalVisualStudioGenerator::ComputeTargetDepends() for(std::vector<cmLocalGenerator*>::iterator i = gen.begin(); i != gen.end(); ++i) { - cmTargets& targets = (*i)->GetMakefile()->GetTargets(); - for(cmTargets::iterator ti = targets.begin(); + std::vector<cmGeneratorTarget*> targets = (*i)->GetGeneratorTargets(); + for(std::vector<cmGeneratorTarget*>::iterator ti = targets.begin(); ti != targets.end(); ++ti) { - this->ComputeVSTargetDepends(ti->second); + this->ComputeVSTargetDepends(*ti); } } } @@ -391,19 +387,20 @@ bool cmGlobalVisualStudioGenerator::ComputeTargetDepends() } //---------------------------------------------------------------------------- -static bool VSLinkable(cmTarget const* t) +static bool VSLinkable(cmGeneratorTarget const* t) { - return t->IsLinkable() || t->GetType() == cmTarget::OBJECT_LIBRARY; + return t->IsLinkable() || t->GetType() == cmState::OBJECT_LIBRARY; } //---------------------------------------------------------------------------- -void cmGlobalVisualStudioGenerator::ComputeVSTargetDepends(cmTarget& target) +void cmGlobalVisualStudioGenerator::ComputeVSTargetDepends( + cmGeneratorTarget* target) { - if(this->VSTargetDepends.find(&target) != this->VSTargetDepends.end()) + if(this->VSTargetDepends.find(target) != this->VSTargetDepends.end()) { return; } - VSDependSet& vsTargetDepend = this->VSTargetDepends[&target]; + VSDependSet& vsTargetDepend = this->VSTargetDepends[target]; // VS <= 7.1 has two behaviors that affect solution dependencies. // // (1) Solution-level dependencies between a linkable target and a @@ -423,19 +420,18 @@ void cmGlobalVisualStudioGenerator::ComputeVSTargetDepends(cmTarget& target) // leaving them out for the static library itself but following them // transitively for other targets. - bool allowLinkable = (target.GetType() != cmTarget::STATIC_LIBRARY && - target.GetType() != cmTarget::SHARED_LIBRARY && - target.GetType() != cmTarget::MODULE_LIBRARY && - target.GetType() != cmTarget::EXECUTABLE); + bool allowLinkable = (target->GetType() != cmState::STATIC_LIBRARY && + target->GetType() != cmState::SHARED_LIBRARY && + target->GetType() != cmState::MODULE_LIBRARY && + target->GetType() != cmState::EXECUTABLE); - cmGeneratorTarget* gt = this->GetGeneratorTarget(&target); - TargetDependSet const& depends = this->GetTargetDirectDepends(gt); + TargetDependSet const& depends = this->GetTargetDirectDepends(target); // Collect implicit link dependencies (target_link_libraries). // Static libraries cannot depend on their link implementation // due to behavior (2), but they do not really need to. - std::set<cmTarget const*> linkDepends; - if(target.GetType() != cmTarget::STATIC_LIBRARY) + std::set<cmGeneratorTarget const*> linkDepends; + if(target->GetType() != cmState::STATIC_LIBRARY) { for(TargetDependSet::const_iterator di = depends.begin(); di != depends.end(); ++di) @@ -443,54 +439,54 @@ void cmGlobalVisualStudioGenerator::ComputeVSTargetDepends(cmTarget& target) cmTargetDepend dep = *di; if(dep.IsLink()) { - this->FollowLinkDepends(dep->Target, linkDepends); + this->FollowLinkDepends(*di, linkDepends); } } } // Collect explicit util dependencies (add_dependencies). - std::set<cmTarget const*> utilDepends; + std::set<cmGeneratorTarget const*> utilDepends; for(TargetDependSet::const_iterator di = depends.begin(); di != depends.end(); ++di) { cmTargetDepend dep = *di; if(dep.IsUtil()) { - this->FollowLinkDepends(dep->Target, utilDepends); + this->FollowLinkDepends(*di, utilDepends); } } // Collect all targets linked by this target so we can avoid // intermediate targets below. TargetSet linked; - if(target.GetType() != cmTarget::STATIC_LIBRARY) + if(target->GetType() != cmState::STATIC_LIBRARY) { - linked = this->GetTargetLinkClosure(&target); + linked = this->GetTargetLinkClosure(target); } // Emit link dependencies. - for(std::set<cmTarget const*>::iterator di = linkDepends.begin(); + for(std::set<cmGeneratorTarget const*>::iterator di = linkDepends.begin(); di != linkDepends.end(); ++di) { - cmTarget const* dep = *di; + cmGeneratorTarget const* dep = *di; vsTargetDepend.insert(dep->GetName()); } // Emit util dependencies. Possibly use intermediate targets. - for(std::set<cmTarget const*>::iterator di = utilDepends.begin(); + for(std::set<cmGeneratorTarget const*>::iterator di = utilDepends.begin(); di != utilDepends.end(); ++di) { - cmTarget const* dep = *di; - if(allowLinkable || !VSLinkable(dep) || linked.count(dep)) + cmGeneratorTarget const* dgt = *di; + if(allowLinkable || !VSLinkable(dgt) || linked.count(dgt)) { // Direct dependency allowed. - vsTargetDepend.insert(dep->GetName()); + vsTargetDepend.insert(dgt->GetName()); } else { // Direct dependency on linkable target not allowed. // Use an intermediate utility target. - vsTargetDepend.insert(this->GetUtilityDepend(dep)); + vsTargetDepend.insert(this->GetUtilityDepend(dgt)); } } } @@ -510,7 +506,8 @@ void cmGlobalVisualStudioGenerator::FindMakeProgram(cmMakefile* mf) //---------------------------------------------------------------------------- std::string -cmGlobalVisualStudioGenerator::GetUtilityDepend(cmTarget const* target) +cmGlobalVisualStudioGenerator::GetUtilityDepend( + cmGeneratorTarget const* target) { UtilityDependsMap::iterator i = this->UtilityDepends.find(target); if(i == this->UtilityDepends.end()) @@ -833,10 +830,8 @@ void RegisterVisualStudioMacros(const std::string& macrosFile, } } bool -cmGlobalVisualStudioGenerator::TargetIsFortranOnly(cmTarget const& target) +cmGlobalVisualStudioGenerator::TargetIsFortranOnly(cmGeneratorTarget const* gt) { - cmGeneratorTarget* gt = this->GetGeneratorTarget(&target); - // check to see if this is a fortran build std::set<std::string> languages; { @@ -895,9 +890,7 @@ cmGlobalVisualStudioGenerator::OrderedTargetDependSet for (TargetSet::const_iterator it = targets.begin(); it != targets.end(); ++it) { - cmGeneratorTarget* gt = - (*it)->GetMakefile()->GetGlobalGenerator()->GetGeneratorTarget(*it); - this->insert(gt); + this->insert(*it); } } diff --git a/Source/cmGlobalVisualStudioGenerator.h b/Source/cmGlobalVisualStudioGenerator.h index c940eb3..f827f26 100644 --- a/Source/cmGlobalVisualStudioGenerator.h +++ b/Source/cmGlobalVisualStudioGenerator.h @@ -73,7 +73,7 @@ public: const char* vsSolutionFile = 0); // return true if target is fortran only - bool TargetIsFortranOnly(cmTarget const& t); + bool TargetIsFortranOnly(const cmGeneratorTarget *gt); /** Get the top-level registry key for this VS version. */ std::string GetRegistryBase(); @@ -88,7 +88,7 @@ public: /** Return true if building for Windows CE */ virtual bool TargetsWindowsCE() const { return false; } - class TargetSet: public std::set<cmTarget const*> {}; + class TargetSet: public std::set<cmGeneratorTarget const*> {}; class TargetCompare { std::string First; @@ -111,7 +111,7 @@ public: cmGeneratorTarget*, std::vector<cmCustomCommand>& commands, std::string const& configName); protected: - virtual bool Compute(); + virtual void AddExtraIDETargets(); // Does this VS version link targets to each other if there are // dependencies in the SLN file? This was done for VS versions @@ -122,15 +122,16 @@ protected: virtual bool ComputeTargetDepends(); class VSDependSet: public std::set<std::string> {}; - class VSDependMap: public std::map<cmTarget const*, VSDependSet> {}; + class VSDependMap: public std::map<cmGeneratorTarget const*, VSDependSet> {}; VSDependMap VSTargetDepends; - void ComputeVSTargetDepends(cmTarget&); - - bool CheckTargetLinks(cmTarget& target, const std::string& name); - std::string GetUtilityForTarget(cmTarget& target, const std::string&); - virtual std::string WriteUtilityDepend(cmTarget const*) = 0; - std::string GetUtilityDepend(cmTarget const* target); - typedef std::map<cmTarget const*, std::string> UtilityDependsMap; + void ComputeVSTargetDepends(cmGeneratorTarget *); + + bool CheckTargetLinks(cmGeneratorTarget& target, const std::string& name); + std::string GetUtilityForTarget(cmGeneratorTarget& target, + const std::string&); + virtual std::string WriteUtilityDepend(cmGeneratorTarget const*) = 0; + std::string GetUtilityDepend(const cmGeneratorTarget *target); + typedef std::map<cmGeneratorTarget const*, std::string> UtilityDependsMap; UtilityDependsMap UtilityDepends; protected: @@ -141,13 +142,14 @@ private: void PrintCompilerAdvice(std::ostream&, std::string const&, const char*) const {} - void FollowLinkDepends(cmTarget const* target, - std::set<cmTarget const*>& linked); + void FollowLinkDepends(cmGeneratorTarget const* target, + std::set<cmGeneratorTarget const*>& linked); - class TargetSetMap: public std::map<cmTarget*, TargetSet> {}; + class TargetSetMap: public std::map<cmGeneratorTarget*, TargetSet> {}; TargetSetMap TargetLinkClosure; - void FillLinkClosure(cmTarget const* target, TargetSet& linked); - TargetSet const& GetTargetLinkClosure(cmTarget* target); + void FillLinkClosure(const cmGeneratorTarget *target, + TargetSet& linked); + TargetSet const& GetTargetLinkClosure(cmGeneratorTarget* target); }; class cmGlobalVisualStudioGenerator::OrderedTargetDependSet: diff --git a/Source/cmGlobalXCodeGenerator.cxx b/Source/cmGlobalXCodeGenerator.cxx index 33babec..475efa8 100644 --- a/Source/cmGlobalXCodeGenerator.cxx +++ b/Source/cmGlobalXCodeGenerator.cxx @@ -125,6 +125,8 @@ public: virtual void GetGenerators(std::vector<std::string>& names) const { names.push_back(cmGlobalXCodeGenerator::GetActualName()); } + + virtual bool SupportsToolset() const { return true; } }; //---------------------------------------------------------------------------- @@ -376,14 +378,8 @@ cmGlobalXCodeGenerator::CreateLocalGenerator(cmMakefile* mf) return new cmLocalXCodeGenerator(this, mf); } -//---------------------------------------------------------------------------- -bool cmGlobalXCodeGenerator::Compute() +void cmGlobalXCodeGenerator::AddExtraIDETargets() { - if (!cmGlobalGenerator::Compute()) - { - return false; - } - std::map<std::string, std::vector<cmLocalGenerator*> >::iterator it; // make sure extra targets are added before calling // the parent generate which will call trace depends @@ -394,7 +390,6 @@ bool cmGlobalXCodeGenerator::Compute() // add ALL_BUILD, INSTALL, etc this->AddExtraTargets(root, it->second); } - return true; } void cmGlobalXCodeGenerator::Generate() @@ -417,15 +412,17 @@ void cmGlobalXCodeGenerator::Generate() //---------------------------------------------------------------------------- void cmGlobalXCodeGenerator::SetGenerationRoot(cmLocalGenerator* root) { - this->CurrentProject = root->GetMakefile()->GetProjectName(); + this->CurrentProject = root->GetProjectName(); this->SetCurrentLocalGenerator(root); - cmSystemTools::SplitPath(this->CurrentMakefile->GetCurrentSourceDirectory(), - this->ProjectSourceDirectoryComponents); - cmSystemTools::SplitPath(this->CurrentMakefile->GetCurrentBinaryDirectory(), - this->ProjectOutputDirectoryComponents); + cmSystemTools::SplitPath( + this->CurrentLocalGenerator->GetCurrentSourceDirectory(), + this->ProjectSourceDirectoryComponents); + cmSystemTools::SplitPath( + this->CurrentLocalGenerator->GetCurrentBinaryDirectory(), + this->ProjectOutputDirectoryComponents); this->CurrentXCodeHackMakefile = - root->GetMakefile()->GetCurrentBinaryDirectory(); + root->GetCurrentBinaryDirectory(); this->CurrentXCodeHackMakefile += "/CMakeScripts"; cmSystemTools::MakeDirectory(this->CurrentXCodeHackMakefile.c_str()); this->CurrentXCodeHackMakefile += "/XCODE_DEPEND_HELPER.make"; @@ -464,16 +461,16 @@ cmGlobalXCodeGenerator::AddExtraTargets(cmLocalGenerator* root, "echo", "Build all projects"); cmGeneratorTarget* allBuildGt = new cmGeneratorTarget(allbuild, root); - mf->AddGeneratorTarget(allbuild, allBuildGt); + root->AddGeneratorTarget(allBuildGt); // Refer to the main build configuration file for easy editing. - std::string listfile = mf->GetCurrentSourceDirectory(); + std::string listfile = root->GetCurrentSourceDirectory(); listfile += "/"; listfile += "CMakeLists.txt"; - allbuild->AddSourceCMP0049(listfile.c_str()); + allBuildGt->AddSource(listfile.c_str()); // Add XCODE depend helper - std::string dir = mf->GetCurrentBinaryDirectory(); + std::string dir = root->GetCurrentBinaryDirectory(); cmCustomCommandLine makeHelper; if(this->XcodeVersion < 50) { @@ -499,7 +496,7 @@ cmGlobalXCodeGenerator::AddExtraTargets(cmLocalGenerator* root, "make", "-f", file.c_str()); cmGeneratorTarget* checkGt = new cmGeneratorTarget(check, root); - mf->AddGeneratorTarget(check, checkGt); + root->AddGeneratorTarget(checkGt); } // now make the allbuild depend on all the non-utility targets @@ -513,19 +510,22 @@ cmGlobalXCodeGenerator::AddExtraTargets(cmLocalGenerator* root, continue; } - cmTargets& tgts = lg->GetMakefile()->GetTargets(); - for(cmTargets::iterator l = tgts.begin(); l != tgts.end(); l++) + std::vector<cmGeneratorTarget*> tgts = lg->GetGeneratorTargets(); + for(std::vector<cmGeneratorTarget*>::iterator l = tgts.begin(); + l != tgts.end(); l++) { - cmTarget& target = l->second; + cmGeneratorTarget* target = *l; - if (target.GetType() == cmTarget::GLOBAL_TARGET) + if (target->GetType() == cmState::GLOBAL_TARGET) { continue; } - if (regenerate && (l->first != CMAKE_CHECK_BUILD_SYSTEM_TARGET)) + std::string targetName = target->GetName(); + + if (regenerate && (targetName != CMAKE_CHECK_BUILD_SYSTEM_TARGET)) { - target.AddUtility(CMAKE_CHECK_BUILD_SYSTEM_TARGET); + target->Target->AddUtility(CMAKE_CHECK_BUILD_SYSTEM_TARGET); } // make all exe, shared libs and modules @@ -533,19 +533,19 @@ cmGlobalXCodeGenerator::AddExtraTargets(cmLocalGenerator* root, // this will make sure that when the next target is built // things are up-to-date if(!makeHelper.empty() && - (target.GetType() == cmTarget::EXECUTABLE || + (target->GetType() == cmState::EXECUTABLE || // Nope - no post-build for OBJECT_LIRBRARY -// target.GetType() == cmTarget::OBJECT_LIBRARY || - target.GetType() == cmTarget::STATIC_LIBRARY || - target.GetType() == cmTarget::SHARED_LIBRARY || - target.GetType() == cmTarget::MODULE_LIBRARY)) +// target->GetType() == cmState::OBJECT_LIBRARY || + target->GetType() == cmState::STATIC_LIBRARY || + target->GetType() == cmState::SHARED_LIBRARY || + target->GetType() == cmState::MODULE_LIBRARY)) { makeHelper[makeHelper.size()-1] = // fill placeholder - this->PostBuildMakeTarget(target.GetName(), "$(CONFIGURATION)"); + this->PostBuildMakeTarget(target->GetName(), "$(CONFIGURATION)"); cmCustomCommandLines commandLines; commandLines.push_back(makeHelper); std::vector<std::string> no_byproducts; - lg->GetMakefile()->AddCustomCommandToTarget(target.GetName(), + lg->GetMakefile()->AddCustomCommandToTarget(target->GetName(), no_byproducts, no_depends, commandLines, @@ -554,17 +554,17 @@ cmGlobalXCodeGenerator::AddExtraTargets(cmLocalGenerator* root, dir.c_str()); } - if(target.GetType() != cmTarget::INTERFACE_LIBRARY - && !target.GetPropertyAsBool("EXCLUDE_FROM_ALL")) + if(target->GetType() != cmState::INTERFACE_LIBRARY + && !target->GetPropertyAsBool("EXCLUDE_FROM_ALL")) { - allbuild->AddUtility(target.GetName()); + allbuild->AddUtility(target->GetName()); } // Refer to the build configuration file for easy editing. - listfile = lg->GetMakefile()->GetCurrentSourceDirectory(); + listfile = lg->GetCurrentSourceDirectory(); listfile += "/"; listfile += "CMakeLists.txt"; - target.AddSourceCMP0049(listfile.c_str()); + target->AddSource(listfile.c_str()); } } } @@ -573,7 +573,6 @@ cmGlobalXCodeGenerator::AddExtraTargets(cmLocalGenerator* root, void cmGlobalXCodeGenerator::CreateReRunCMakeFile( cmLocalGenerator* root, std::vector<cmLocalGenerator*> const& gens) { - cmMakefile* mf = root->GetMakefile(); std::vector<std::string> lfiles; for(std::vector<cmLocalGenerator*>::const_iterator gi = gens.begin(); gi != gens.end(); ++gi) @@ -587,7 +586,7 @@ void cmGlobalXCodeGenerator::CreateReRunCMakeFile( std::vector<std::string>::iterator new_end = std::unique(lfiles.begin(), lfiles.end()); lfiles.erase(new_end, lfiles.end()); - this->CurrentReRunCMakeMakefile = mf->GetCurrentBinaryDirectory(); + this->CurrentReRunCMakeMakefile = root->GetCurrentBinaryDirectory(); this->CurrentReRunCMakeMakefile += "/CMakeScripts"; cmSystemTools::MakeDirectory(this->CurrentReRunCMakeMakefile.c_str()); this->CurrentReRunCMakeMakefile += "/ReRunCMake.make"; @@ -595,7 +594,7 @@ void cmGlobalXCodeGenerator::CreateReRunCMakeFile( (this->CurrentReRunCMakeMakefile.c_str()); makefileStream.SetCopyIfDifferent(true); makefileStream << "# Generated by CMake, DO NOT EDIT\n"; - std::string checkCache = mf->GetHomeOutputDirectory(); + std::string checkCache = root->GetBinaryDirectory(); checkCache += "/"; checkCache += cmake::GetCMakeFilesDirectoryPostSlash(); checkCache += "cmake.check_cache"; @@ -609,9 +608,9 @@ void cmGlobalXCodeGenerator::CreateReRunCMakeFile( makefileStream << "\n\t" << this->ConvertToRelativeForMake(cmSystemTools::GetCMakeCommand().c_str()) << " -H" << this->ConvertToRelativeForMake( - mf->GetHomeDirectory()) + root->GetSourceDirectory()) << " -B" << this->ConvertToRelativeForMake( - mf->GetHomeOutputDirectory()) << "\n"; + root->GetBinaryDirectory()) << "\n"; } //---------------------------------------------------------------------------- @@ -712,9 +711,9 @@ cmXCodeObject* cmGlobalXCodeGenerator //---------------------------------------------------------------------------- std::string -GetGroupMapKeyFromPath(cmTarget& cmtarget, const std::string& fullpath) +GetGroupMapKeyFromPath(cmGeneratorTarget* target, const std::string& fullpath) { - std::string key(cmtarget.GetName()); + std::string key(target->GetName()); key += "-"; key += fullpath; return key; @@ -722,16 +721,16 @@ GetGroupMapKeyFromPath(cmTarget& cmtarget, const std::string& fullpath) //---------------------------------------------------------------------------- std::string -GetGroupMapKey(cmTarget& cmtarget, cmSourceFile* sf) +GetGroupMapKey(cmGeneratorTarget* target, cmSourceFile* sf) { - return GetGroupMapKeyFromPath(cmtarget, sf->GetFullPath()); + return GetGroupMapKeyFromPath(target, sf->GetFullPath()); } //---------------------------------------------------------------------------- cmXCodeObject* cmGlobalXCodeGenerator::CreateXCodeSourceFileFromPath( const std::string &fullpath, - cmTarget& cmtarget, + cmGeneratorTarget* target, const std::string &lang, cmSourceFile* sf) { @@ -739,7 +738,7 @@ cmGlobalXCodeGenerator::CreateXCodeSourceFileFromPath( // fileRef object for any given full path. // cmXCodeObject* fileRef = - this->CreateXCodeFileReferenceFromPath(fullpath, cmtarget, lang, sf); + this->CreateXCodeFileReferenceFromPath(fullpath, target, lang, sf); cmXCodeObject* buildFile = this->CreateObject(cmXCodeObject::PBXBuildFile); buildFile->SetComment(fileRef->GetComment()); @@ -752,7 +751,7 @@ cmGlobalXCodeGenerator::CreateXCodeSourceFileFromPath( cmXCodeObject* cmGlobalXCodeGenerator::CreateXCodeSourceFile(cmLocalGenerator* lg, cmSourceFile* sf, - cmTarget& cmtarget) + cmGeneratorTarget* gtgt) { // Add flags from target and source file properties. std::string flags; @@ -782,7 +781,7 @@ cmGlobalXCodeGenerator::CreateXCodeSourceFile(cmLocalGenerator* lg, this->CurrentLocalGenerator->GetSourceFileLanguage(*sf); cmXCodeObject* buildFile = - this->CreateXCodeSourceFileFromPath(sf->GetFullPath(), cmtarget, lang, sf); + this->CreateXCodeSourceFileFromPath(sf->GetFullPath(), gtgt, lang, sf); cmXCodeObject* fileRef = buildFile->GetObject("fileRef")->GetObject(); cmXCodeObject* settings = @@ -791,14 +790,15 @@ cmGlobalXCodeGenerator::CreateXCodeSourceFile(cmLocalGenerator* lg, // Is this a resource file in this target? Add it to the resources group... // + cmGeneratorTarget::SourceFileFlags tsFlags = - this->GetGeneratorTarget(&cmtarget)->GetTargetSourceFileFlags(sf); + gtgt->GetTargetSourceFileFlags(sf); bool isResource = tsFlags.Type == cmGeneratorTarget::SourceFileTypeResource; // Is this a "private" or "public" framework header file? // Set the ATTRIBUTES attribute appropriately... // - if(cmtarget.IsFrameworkOnApple()) + if(gtgt->IsFrameworkOnApple()) { if(tsFlags.Type == cmGeneratorTarget::SourceFileTypePrivateHeader) { @@ -925,11 +925,11 @@ GetSourcecodeValueFromFileExtension(const std::string& _ext, cmXCodeObject* cmGlobalXCodeGenerator::CreateXCodeFileReferenceFromPath( const std::string &fullpath, - cmTarget& cmtarget, + cmGeneratorTarget* target, const std::string &lang, cmSourceFile* sf) { - std::string key = GetGroupMapKeyFromPath(cmtarget, fullpath); + std::string key = GetGroupMapKeyFromPath(target, fullpath); cmXCodeObject* fileRef = this->FileRefs[key]; if(!fileRef) { @@ -1006,13 +1006,13 @@ cmGlobalXCodeGenerator::CreateXCodeFileReferenceFromPath( //---------------------------------------------------------------------------- cmXCodeObject* cmGlobalXCodeGenerator::CreateXCodeFileReference(cmSourceFile* sf, - cmTarget& cmtarget) + cmGeneratorTarget* target) { std::string lang = this->CurrentLocalGenerator->GetSourceFileLanguage(*sf); return this->CreateXCodeFileReferenceFromPath( - sf->GetFullPath(), cmtarget, lang, sf); + sf->GetFullPath(), target, lang, sf); } //---------------------------------------------------------------------------- @@ -1038,7 +1038,7 @@ void cmGlobalXCodeGenerator::SetCurrentLocalGenerator(cmLocalGenerator* gen) this->CurrentLocalGenerator = gen; this->CurrentMakefile = gen->GetMakefile(); std::string outdir = - cmSystemTools::CollapseFullPath(this->CurrentMakefile-> + cmSystemTools::CollapseFullPath(this->CurrentLocalGenerator-> GetCurrentBinaryDirectory()); cmSystemTools::SplitPath(outdir.c_str(), this->CurrentOutputDirectoryComponents); @@ -1085,34 +1085,38 @@ cmGlobalXCodeGenerator::CreateXCodeTargets(cmLocalGenerator* gen, targets) { this->SetCurrentLocalGenerator(gen); - cmTargets &tgts = this->CurrentMakefile->GetTargets(); - typedef std::map<std::string, cmTarget*, cmCompareTargets> cmSortedTargets; + std::vector<cmGeneratorTarget*> tgts = + this->CurrentLocalGenerator->GetGeneratorTargets(); + typedef std::map<std::string, cmGeneratorTarget*, cmCompareTargets> + cmSortedTargets; cmSortedTargets sortedTargets; - for(cmTargets::iterator l = tgts.begin(); l != tgts.end(); l++) + for(std::vector<cmGeneratorTarget*>::iterator l = tgts.begin(); + l != tgts.end(); l++) { - sortedTargets[l->first] = &l->second; + sortedTargets[(*l)->GetName()] = *l; } for(cmSortedTargets::iterator l = sortedTargets.begin(); l != sortedTargets.end(); l++) { - cmTarget& cmtarget = *l->second; - cmGeneratorTarget* gtgt = this->GetGeneratorTarget(&cmtarget); + cmGeneratorTarget* gtgt = l->second; + + std::string targetName = gtgt->GetName(); // make sure ALL_BUILD, INSTALL, etc are only done once - if(this->SpecialTargetEmitted(l->first.c_str())) + if(this->SpecialTargetEmitted(targetName.c_str())) { continue; } - if(cmtarget.GetType() == cmTarget::INTERFACE_LIBRARY) + if(gtgt->GetType() == cmState::INTERFACE_LIBRARY) { continue; } - if(cmtarget.GetType() == cmTarget::UTILITY || - cmtarget.GetType() == cmTarget::GLOBAL_TARGET) + if(gtgt->GetType() == cmState::UTILITY || + gtgt->GetType() == cmState::GLOBAL_TARGET) { - cmXCodeObject* t = this->CreateUtilityTarget(cmtarget); + cmXCodeObject* t = this->CreateUtilityTarget(gtgt); if (!t) { return false; @@ -1140,7 +1144,7 @@ cmGlobalXCodeGenerator::CreateXCodeTargets(cmLocalGenerator* gen, { cmXCodeObject* xsf = this->CreateXCodeSourceFile(this->CurrentLocalGenerator, - *i, cmtarget); + *i, gtgt); cmXCodeObject* fr = xsf->GetObject("fileRef"); cmXCodeObject* filetype = fr->GetObject()->GetObject("explicitFileType"); @@ -1191,15 +1195,15 @@ cmGlobalXCodeGenerator::CreateXCodeTargets(cmLocalGenerator* gen, { std::string obj = *oi; cmXCodeObject* xsf = - this->CreateXCodeSourceFileFromPath(obj, cmtarget, "", 0); + this->CreateXCodeSourceFileFromPath(obj, gtgt, "", 0); externalObjFiles.push_back(xsf); } } // some build phases only apply to bundles and/or frameworks - bool isFrameworkTarget = cmtarget.IsFrameworkOnApple(); - bool isBundleTarget = cmtarget.GetPropertyAsBool("MACOSX_BUNDLE"); - bool isCFBundleTarget = cmtarget.IsCFBundleOnApple(); + bool isFrameworkTarget = gtgt->IsFrameworkOnApple(); + bool isBundleTarget = gtgt->GetPropertyAsBool("MACOSX_BUNDLE"); + bool isCFBundleTarget = gtgt->IsCFBundleOnApple(); cmXCodeObject* buildFiles = 0; @@ -1293,7 +1297,7 @@ cmGlobalXCodeGenerator::CreateXCodeTargets(cmLocalGenerator* gen, copyFilesBuildPhase->AddAttribute("dstSubfolderSpec", this->CreateString("6")); std::ostringstream ostr; - if (cmtarget.IsFrameworkOnApple()) + if (gtgt->IsFrameworkOnApple()) { // dstPath in frameworks is relative to Versions/<version> ostr << mit->first; @@ -1314,7 +1318,7 @@ cmGlobalXCodeGenerator::CreateXCodeTargets(cmLocalGenerator* gen, { cmXCodeObject* xsf = this->CreateXCodeSourceFile(this->CurrentLocalGenerator, - *sfIt, cmtarget); + *sfIt, gtgt); buildFiles->AddObject(xsf); } contentBuildPhases.push_back(copyFilesBuildPhase); @@ -1348,9 +1352,9 @@ cmGlobalXCodeGenerator::CreateXCodeTargets(cmLocalGenerator* gen, this->CreateCustomCommands(buildPhases, sourceBuildPhase, headerBuildPhase, resourceBuildPhase, contentBuildPhases, - frameworkBuildPhase, cmtarget); + frameworkBuildPhase, gtgt); - targets.push_back(this->CreateXCodeTarget(cmtarget, buildPhases)); + targets.push_back(this->CreateXCodeTarget(gtgt, buildPhases)); } return true; } @@ -1358,26 +1362,31 @@ cmGlobalXCodeGenerator::CreateXCodeTargets(cmLocalGenerator* gen, //---------------------------------------------------------------------------- void cmGlobalXCodeGenerator::ForceLinkerLanguages() { - // This makes sure all targets link using the proper language. - for(TargetMap::const_iterator - ti = this->TotalTargets.begin(); ti != this->TotalTargets.end(); ++ti) + for (unsigned int i = 0; i < this->LocalGenerators.size(); ++i) { - this->ForceLinkerLanguage(*ti->second); + std::vector<cmGeneratorTarget*> tgts = + this->LocalGenerators[i]->GetGeneratorTargets(); + // All targets depend on the build-system check target. + for(std::vector<cmGeneratorTarget*>::const_iterator ti = tgts.begin(); + ti != tgts.end(); ++ti) + { + // This makes sure all targets link using the proper language. + this->ForceLinkerLanguage(*ti); + } } } //---------------------------------------------------------------------------- -void cmGlobalXCodeGenerator::ForceLinkerLanguage(cmTarget& cmtarget) +void cmGlobalXCodeGenerator::ForceLinkerLanguage(cmGeneratorTarget* gtgt) { // This matters only for targets that link. - if(cmtarget.GetType() != cmTarget::EXECUTABLE && - cmtarget.GetType() != cmTarget::SHARED_LIBRARY && - cmtarget.GetType() != cmTarget::MODULE_LIBRARY) + if(gtgt->GetType() != cmState::EXECUTABLE && + gtgt->GetType() != cmState::SHARED_LIBRARY && + gtgt->GetType() != cmState::MODULE_LIBRARY) { return; } - cmGeneratorTarget *gtgt = this->GetGeneratorTarget(&cmtarget); std::string llang = gtgt->GetLinkerLanguage("NOCONFIG"); if(llang.empty()) { return; } @@ -1393,11 +1402,11 @@ void cmGlobalXCodeGenerator::ForceLinkerLanguage(cmTarget& cmtarget) // Add an empty source file to the target that compiles with the // linker language. This should convince Xcode to choose the proper // language. - cmMakefile* mf = cmtarget.GetMakefile(); - std::string fname = mf->GetCurrentBinaryDirectory(); + cmMakefile* mf = gtgt->Target->GetMakefile(); + std::string fname = gtgt->GetLocalGenerator()->GetCurrentBinaryDirectory(); fname += cmake::GetCMakeFilesDirectory(); fname += "/"; - fname += cmtarget.GetName(); + fname += gtgt->GetName(); fname += "-CMakeForceLinker"; fname += "."; fname += cmSystemTools::LowerCase(llang); @@ -1408,7 +1417,7 @@ void cmGlobalXCodeGenerator::ForceLinkerLanguage(cmTarget& cmtarget) if(cmSourceFile* sf = mf->GetOrCreateSource(fname.c_str())) { sf->SetProperty("LANGUAGE", llang.c_str()); - cmtarget.AddSource(fname); + gtgt->AddSource(fname); } } @@ -1416,7 +1425,7 @@ void cmGlobalXCodeGenerator::ForceLinkerLanguage(cmTarget& cmtarget) bool cmGlobalXCodeGenerator::IsHeaderFile(cmSourceFile* sf) { const std::vector<std::string>& hdrExts = - this->CurrentMakefile->GetHeaderExtensions(); + this->CMakeInstance->GetHeaderExtensions(); return (std::find(hdrExts.begin(), hdrExts.end(), sf->GetExtension()) != hdrExts.end()); } @@ -1425,7 +1434,7 @@ bool cmGlobalXCodeGenerator::IsHeaderFile(cmSourceFile* sf) cmXCodeObject* cmGlobalXCodeGenerator::CreateBuildPhase(const char* name, const char* name2, - cmTarget& cmtarget, + cmGeneratorTarget* target, const std::vector<cmCustomCommand>& commands) { @@ -1445,7 +1454,7 @@ cmGlobalXCodeGenerator::CreateBuildPhase(const char* name, this->CreateString("0")); buildPhase->AddAttribute("shellPath", this->CreateString("/bin/sh")); - this->AddCommandsToBuildPhase(buildPhase, cmtarget, commands, + this->AddCommandsToBuildPhase(buildPhase, target, commands, name2); return buildPhase; } @@ -1462,17 +1471,17 @@ void cmGlobalXCodeGenerator::CreateCustomCommands(cmXCodeObject* buildPhases, contentBuildPhases, cmXCodeObject* frameworkBuildPhase, - cmTarget& cmtarget) + cmGeneratorTarget* gtgt) { std::vector<cmCustomCommand> const & prebuild - = cmtarget.GetPreBuildCommands(); + = gtgt->GetPreBuildCommands(); std::vector<cmCustomCommand> const & prelink - = cmtarget.GetPreLinkCommands(); + = gtgt->GetPreLinkCommands(); std::vector<cmCustomCommand> postbuild - = cmtarget.GetPostBuildCommands(); + = gtgt->GetPostBuildCommands(); - if(cmtarget.GetType() == cmTarget::SHARED_LIBRARY && - !cmtarget.IsFrameworkOnApple()) + if(gtgt->GetType() == cmState::SHARED_LIBRARY && + !gtgt->IsFrameworkOnApple()) { cmCustomCommandLines cmd; cmd.resize(1); @@ -1480,13 +1489,13 @@ void cmGlobalXCodeGenerator::CreateCustomCommands(cmXCodeObject* buildPhases, cmd[0].push_back("-E"); cmd[0].push_back("cmake_symlink_library"); std::string str_file = "$<TARGET_FILE:"; - str_file += cmtarget.GetName(); + str_file += gtgt->GetName(); str_file += ">"; std::string str_so_file = "$<TARGET_SONAME_FILE:"; - str_so_file += cmtarget.GetName(); + str_so_file += gtgt->GetName(); str_so_file += ">"; std::string str_link_file = "$<TARGET_LINKER_FILE:"; - str_link_file += cmtarget.GetName(); + str_link_file += gtgt->GetName(); str_link_file += ">"; cmd[0].push_back(str_file); cmd[0].push_back(str_so_file); @@ -1504,7 +1513,6 @@ void cmGlobalXCodeGenerator::CreateCustomCommands(cmXCodeObject* buildPhases, } std::vector<cmSourceFile*> classes; - cmGeneratorTarget* gtgt = this->GetGeneratorTarget(&cmtarget); if (!gtgt->GetConfigCommonSourceFiles(classes)) { return; @@ -1523,19 +1531,19 @@ void cmGlobalXCodeGenerator::CreateCustomCommands(cmXCodeObject* buildPhases, cmXCodeObject* cmakeRulesBuildPhase = this->CreateBuildPhase("CMake Rules", "cmakeRulesBuildPhase", - cmtarget, commands); + gtgt, commands); // create prebuild phase cmXCodeObject* preBuildPhase = this->CreateBuildPhase("CMake PreBuild Rules", "preBuildCommands", - cmtarget, prebuild); + gtgt, prebuild); // create prelink phase cmXCodeObject* preLinkPhase = this->CreateBuildPhase("CMake PreLink Rules", "preLinkCommands", - cmtarget, prelink); + gtgt, prelink); // create postbuild phase cmXCodeObject* postBuildPhase = this->CreateBuildPhase("CMake PostBuild Rules", "postBuildPhase", - cmtarget, postbuild); + gtgt, postbuild); // The order here is the order they will be built in. // The order "headers, resources, sources" mimics a native project generated @@ -1616,19 +1624,52 @@ std::string cmGlobalXCodeGenerator::ExtractFlag(const char* flag, } //---------------------------------------------------------------------------- +// This function removes each matching occurrence of the expression and +// returns the last one (i.e., the dominant flag in GCC) +std::string cmGlobalXCodeGenerator::ExtractFlagRegex(const char* exp, + int matchIndex, + std::string& flags) +{ + std::string retFlag; + + cmsys::RegularExpression regex(exp); + assert(regex.is_valid()); + if(!regex.is_valid()) + { + return retFlag; + } + + std::string::size_type offset = 0; + + while(regex.find(flags.c_str() + offset)) + { + const std::string::size_type startPos = offset + regex.start(matchIndex); + const std::string::size_type endPos = offset + regex.end(matchIndex); + const std::string::size_type size = endPos - startPos; + + offset = startPos + 1; + + retFlag.assign(flags, startPos, size); + flags.replace(startPos, size, size, ' '); + } + + return retFlag; +} + +//---------------------------------------------------------------------------- void cmGlobalXCodeGenerator::AddCommandsToBuildPhase(cmXCodeObject* buildphase, - cmTarget& target, + cmGeneratorTarget* target, std::vector<cmCustomCommand> const & commands, const char* name) { - std::string dir = this->CurrentMakefile->GetCurrentBinaryDirectory(); + std::string dir = this->CurrentLocalGenerator->GetCurrentBinaryDirectory(); dir += "/CMakeScripts"; cmSystemTools::MakeDirectory(dir.c_str()); std::string makefile = dir; makefile += "/"; - makefile += target.GetName(); + makefile += target->GetName(); makefile += "_"; makefile += name; makefile += ".make"; @@ -1644,7 +1685,7 @@ cmGlobalXCodeGenerator::AddCommandsToBuildPhase(cmXCodeObject* buildphase, currentConfig->c_str()); } - std::string cdir = this->CurrentMakefile->GetCurrentBinaryDirectory(); + std::string cdir = this->CurrentLocalGenerator->GetCurrentBinaryDirectory(); cdir = this->ConvertToRelativeForXCode(cdir.c_str()); std::string makecmd = "make -C "; makecmd += cdir; @@ -1662,7 +1703,7 @@ cmGlobalXCodeGenerator::AddCommandsToBuildPhase(cmXCodeObject* buildphase, //---------------------------------------------------------------------------- void cmGlobalXCodeGenerator ::CreateCustomRulesMakefile(const char* makefileBasename, - cmTarget& target, + cmGeneratorTarget* target, std::vector<cmCustomCommand> const & commands, const std::string& configName) @@ -1679,7 +1720,7 @@ void cmGlobalXCodeGenerator } makefileStream.SetCopyIfDifferent(true); makefileStream << "# Generated by CMake, DO NOT EDIT\n"; - makefileStream << "# Custom rules for " << target.GetName() << "\n"; + makefileStream << "# Custom rules for " << target->GetName() << "\n"; // disable the implicit rules makefileStream << ".SUFFIXES: " << "\n"; @@ -1708,7 +1749,7 @@ void cmGlobalXCodeGenerator { std::ostringstream str; str << "_buildpart_" << count++ ; - tname[&ccg.GetCC()] = std::string(target.GetName()) + str.str(); + tname[&ccg.GetCC()] = std::string(target->GetName()) + str.str(); makefileStream << "\\\n\t" << tname[&ccg.GetCC()]; } } @@ -1786,26 +1827,25 @@ void cmGlobalXCodeGenerator } //---------------------------------------------------------------------------- -void cmGlobalXCodeGenerator::CreateBuildSettings(cmTarget& target, +void cmGlobalXCodeGenerator::CreateBuildSettings(cmGeneratorTarget* gtgt, cmXCodeObject* buildSettings, const std::string& configName) { - if(target.GetType() == cmTarget::INTERFACE_LIBRARY) + if(gtgt->GetType() == cmState::INTERFACE_LIBRARY) { return; } std::string defFlags; - bool shared = ((target.GetType() == cmTarget::SHARED_LIBRARY) || - (target.GetType() == cmTarget::MODULE_LIBRARY)); - bool binary = ((target.GetType() == cmTarget::OBJECT_LIBRARY) || - (target.GetType() == cmTarget::STATIC_LIBRARY) || - (target.GetType() == cmTarget::EXECUTABLE) || + bool shared = ((gtgt->GetType() == cmState::SHARED_LIBRARY) || + (gtgt->GetType() == cmState::MODULE_LIBRARY)); + bool binary = ((gtgt->GetType() == cmState::OBJECT_LIBRARY) || + (gtgt->GetType() == cmState::STATIC_LIBRARY) || + (gtgt->GetType() == cmState::EXECUTABLE) || shared); // Compute the compilation flags for each language. std::set<std::string> languages; - cmGeneratorTarget *gtgt = this->GetGeneratorTarget(&target); gtgt->GetLanguages(languages, configName); std::map<std::string, std::string> cflags; for (std::set<std::string>::iterator li = languages.begin(); @@ -1818,14 +1858,14 @@ void cmGlobalXCodeGenerator::CreateBuildSettings(cmTarget& target, this->CurrentLocalGenerator->AddLanguageFlags(flags, lang, configName); // Add shared-library flags if needed. - this->CurrentLocalGenerator->AddCMP0018Flags(flags, &target, + this->CurrentLocalGenerator->AddCMP0018Flags(flags, gtgt, lang, configName); - this->CurrentLocalGenerator->AddVisibilityPresetFlags(flags, &target, + this->CurrentLocalGenerator->AddVisibilityPresetFlags(flags, gtgt, lang); this->CurrentLocalGenerator-> - AddCompileOptions(flags, &target, lang, configName); + AddCompileOptions(flags, gtgt, lang, configName); } std::string llang = gtgt->GetLinkerLanguage(configName); @@ -1833,7 +1873,7 @@ void cmGlobalXCodeGenerator::CreateBuildSettings(cmTarget& target, { cmSystemTools::Error ("CMake can not determine linker language for target: ", - target.GetName().c_str()); + gtgt->GetName().c_str()); return; } @@ -1849,7 +1889,7 @@ void cmGlobalXCodeGenerator::CreateBuildSettings(cmTarget& target, this->AppendDefines(ppDefs, "CMAKE_INTDIR=\"$(CONFIGURATION)$(EFFECTIVE_PLATFORM_NAME)\""); } - if(const char* exportMacro = target.GetExportMacro()) + if(const char* exportMacro = gtgt->GetExportMacro()) { // Add the export symbol definition for shared library objects. this->AppendDefines(ppDefs, exportMacro); @@ -1862,15 +1902,15 @@ void cmGlobalXCodeGenerator::CreateBuildSettings(cmTarget& target, std::string extraLinkOptionsVar; std::string extraLinkOptions; - if(target.GetType() == cmTarget::EXECUTABLE) + if(gtgt->GetType() == cmState::EXECUTABLE) { extraLinkOptionsVar = "CMAKE_EXE_LINKER_FLAGS"; } - else if(target.GetType() == cmTarget::SHARED_LIBRARY) + else if(gtgt->GetType() == cmState::SHARED_LIBRARY) { extraLinkOptionsVar = "CMAKE_SHARED_LINKER_FLAGS"; } - else if(target.GetType() == cmTarget::MODULE_LIBRARY) + else if(gtgt->GetType() == cmState::MODULE_LIBRARY) { extraLinkOptionsVar = "CMAKE_MODULE_LINKER_FLAGS"; } @@ -1882,17 +1922,17 @@ void cmGlobalXCodeGenerator::CreateBuildSettings(cmTarget& target, configName); } - if(target.GetType() == cmTarget::OBJECT_LIBRARY || - target.GetType() == cmTarget::STATIC_LIBRARY) + if(gtgt->GetType() == cmState::OBJECT_LIBRARY || + gtgt->GetType() == cmState::STATIC_LIBRARY) { this->CurrentLocalGenerator ->GetStaticLibraryFlags(extraLinkOptions, cmSystemTools::UpperCase(configName), - &target); + gtgt); } else { - const char* targetLinkFlags = target.GetProperty("LINK_FLAGS"); + const char* targetLinkFlags = gtgt->GetProperty("LINK_FLAGS"); if(targetLinkFlags) { this->CurrentLocalGenerator-> @@ -1902,7 +1942,7 @@ void cmGlobalXCodeGenerator::CreateBuildSettings(cmTarget& target, { std::string linkFlagsVar = "LINK_FLAGS_"; linkFlagsVar += cmSystemTools::UpperCase(configName); - if(const char* linkFlags = target.GetProperty(linkFlagsVar.c_str())) + if(const char* linkFlags = gtgt->GetProperty(linkFlagsVar.c_str())) { this->CurrentLocalGenerator-> AppendFlags(extraLinkOptions, linkFlags); @@ -1945,9 +1985,9 @@ void cmGlobalXCodeGenerator::CreateBuildSettings(cmTarget& target, std::string pnsuffix; gtgt->GetFullNameComponents(pnprefix, pnbase, pnsuffix, configName); - const char* version = target.GetProperty("VERSION"); - const char* soversion = target.GetProperty("SOVERSION"); - if(!gtgt->HasSOName(configName) || target.IsFrameworkOnApple()) + const char* version = gtgt->GetProperty("VERSION"); + const char* soversion = gtgt->GetProperty("SOVERSION"); + if(!gtgt->HasSOName(configName) || gtgt->IsFrameworkOnApple()) { version = 0; soversion = 0; @@ -1972,17 +2012,17 @@ void cmGlobalXCodeGenerator::CreateBuildSettings(cmTarget& target, } // Set attributes to specify the proper name for the target. - std::string pndir = this->CurrentMakefile->GetCurrentBinaryDirectory(); - if(target.GetType() == cmTarget::STATIC_LIBRARY || - target.GetType() == cmTarget::SHARED_LIBRARY || - target.GetType() == cmTarget::MODULE_LIBRARY || - target.GetType() == cmTarget::EXECUTABLE) + std::string pndir = this->CurrentLocalGenerator->GetCurrentBinaryDirectory(); + if(gtgt->GetType() == cmState::STATIC_LIBRARY || + gtgt->GetType() == cmState::SHARED_LIBRARY || + gtgt->GetType() == cmState::MODULE_LIBRARY || + gtgt->GetType() == cmState::EXECUTABLE) { if(this->XcodeVersion >= 21) { - if(!target.UsesDefaultOutputDir(configName, false)) + if(!gtgt->UsesDefaultOutputDir(configName, false)) { - std::string pncdir = target.GetDirectory(configName); + std::string pncdir = gtgt->GetDirectory(configName); buildSettings->AddAttribute("CONFIGURATION_BUILD_DIR", this->CreateString(pncdir.c_str())); } @@ -1991,10 +2031,10 @@ void cmGlobalXCodeGenerator::CreateBuildSettings(cmTarget& target, { buildSettings->AddAttribute("OBJROOT", this->CreateString(pndir.c_str())); - pndir = target.GetDirectory(configName); + pndir = gtgt->GetDirectory(configName); } - if(target.IsFrameworkOnApple() || target.IsCFBundleOnApple()) + if(gtgt->IsFrameworkOnApple() || gtgt->IsCFBundleOnApple()) { pnprefix = ""; } @@ -2004,16 +2044,16 @@ void cmGlobalXCodeGenerator::CreateBuildSettings(cmTarget& target, buildSettings->AddAttribute("EXECUTABLE_SUFFIX", this->CreateString(pnsuffix.c_str())); } - else if(target.GetType() == cmTarget::OBJECT_LIBRARY) + else if(gtgt->GetType() == cmState::OBJECT_LIBRARY) { pnprefix = "lib"; - pnbase = target.GetName(); + pnbase = gtgt->GetName(); pnsuffix = ".a"; if(this->XcodeVersion >= 21) { std::string pncdir = this->GetObjectsNormalDirectory( - this->CurrentProject, configName, &target); + this->CurrentProject, configName, gtgt); buildSettings->AddAttribute("CONFIGURATION_BUILD_DIR", this->CreateString(pncdir.c_str())); } @@ -2022,7 +2062,7 @@ void cmGlobalXCodeGenerator::CreateBuildSettings(cmTarget& target, buildSettings->AddAttribute("OBJROOT", this->CreateString(pndir.c_str())); pndir = this->GetObjectsNormalDirectory( - this->CurrentProject, configName, &target); + this->CurrentProject, configName, gtgt); } } @@ -2033,21 +2073,21 @@ void cmGlobalXCodeGenerator::CreateBuildSettings(cmTarget& target, this->CreateString(pndir.c_str())); // Handle settings for each target type. - switch(target.GetType()) + switch(gtgt->GetType()) { - case cmTarget::OBJECT_LIBRARY: - case cmTarget::STATIC_LIBRARY: + case cmState::OBJECT_LIBRARY: + case cmState::STATIC_LIBRARY: { buildSettings->AddAttribute("LIBRARY_STYLE", this->CreateString("STATIC")); break; } - case cmTarget::MODULE_LIBRARY: + case cmState::MODULE_LIBRARY: { buildSettings->AddAttribute("LIBRARY_STYLE", this->CreateString("BUNDLE")); - if (target.IsCFBundleOnApple()) + if (gtgt->IsCFBundleOnApple()) { // It turns out that a BUNDLE is basically the same // in many ways as an application bundle, as far as @@ -2060,13 +2100,13 @@ void cmGlobalXCodeGenerator::CreateBuildSettings(cmTarget& target, extraLinkOptions += " "; extraLinkOptions += createFlags; } - std::string plist = this->ComputeInfoPListLocation(target); + std::string plist = this->ComputeInfoPListLocation(gtgt); // Xcode will create the final version of Info.plist at build time, // so let it replace the cfbundle name. This avoids creating // a per-configuration Info.plist file. The cfbundle plist // is very similar to the application bundle plist this->CurrentLocalGenerator - ->GenerateAppleInfoPList(&target, "$(EXECUTABLE_NAME)", + ->GenerateAppleInfoPList(gtgt, "$(EXECUTABLE_NAME)", plist.c_str()); std::string path = this->ConvertToRelativeForXCode(plist.c_str()); @@ -2102,20 +2142,20 @@ void cmGlobalXCodeGenerator::CreateBuildSettings(cmTarget& target, } break; } - case cmTarget::SHARED_LIBRARY: + case cmState::SHARED_LIBRARY: { - if(target.GetPropertyAsBool("FRAMEWORK")) + if(gtgt->GetPropertyAsBool("FRAMEWORK")) { - std::string fw_version = target.GetFrameworkVersion(); + std::string fw_version = gtgt->GetFrameworkVersion(); buildSettings->AddAttribute("FRAMEWORK_VERSION", this->CreateString(fw_version.c_str())); - std::string plist = this->ComputeInfoPListLocation(target); + std::string plist = this->ComputeInfoPListLocation(gtgt); // Xcode will create the final version of Info.plist at build time, // so let it replace the framework name. This avoids creating // a per-configuration Info.plist file. this->CurrentLocalGenerator - ->GenerateFrameworkInfoPList(&target, "$(EXECUTABLE_NAME)", + ->GenerateFrameworkInfoPList(gtgt, "$(EXECUTABLE_NAME)", plist.c_str()); std::string path = this->ConvertToRelativeForXCode(plist.c_str()); @@ -2139,7 +2179,7 @@ void cmGlobalXCodeGenerator::CreateBuildSettings(cmTarget& target, this->CreateString("DYNAMIC")); break; } - case cmTarget::EXECUTABLE: + case cmState::EXECUTABLE: { // Add the flags to create an executable. std::string createFlags = @@ -2151,14 +2191,14 @@ void cmGlobalXCodeGenerator::CreateBuildSettings(cmTarget& target, } // Handle bundles and normal executables separately. - if(target.GetPropertyAsBool("MACOSX_BUNDLE")) + if(gtgt->GetPropertyAsBool("MACOSX_BUNDLE")) { - std::string plist = this->ComputeInfoPListLocation(target); + std::string plist = this->ComputeInfoPListLocation(gtgt); // Xcode will create the final version of Info.plist at build time, // so let it replace the executable name. This avoids creating // a per-configuration Info.plist file. this->CurrentLocalGenerator - ->GenerateAppleInfoPList(&target, "$(EXECUTABLE_NAME)", + ->GenerateAppleInfoPList(gtgt, "$(EXECUTABLE_NAME)", plist.c_str()); std::string path = this->ConvertToRelativeForXCode(plist.c_str()); @@ -2231,9 +2271,7 @@ void cmGlobalXCodeGenerator::CreateBuildSettings(cmTarget& target, bool same_gflags = true; std::map<std::string, std::string> gflags; std::string const* last_gflag = 0; - char optLevel[2]; - optLevel[0] = '0'; - optLevel[1] = 0; + std::string optLevel = "0"; // Minimal map of flags to build settings. for (std::set<std::string>::iterator li = languages.begin(); @@ -2241,14 +2279,15 @@ void cmGlobalXCodeGenerator::CreateBuildSettings(cmTarget& target, { std::string& flags = cflags[*li]; std::string& gflag = gflags[*li]; - std::string oflag = this->ExtractFlag("-O", flags); - if(oflag.size() == 3) + std::string oflag = + this->ExtractFlagRegex("(^| )(-Ofast|-Os|-O[0-9]*)( |$)", 2, flags); + if(oflag.size() == 2) { - optLevel[0] = oflag[2]; + optLevel = "1"; } - if(oflag.size() == 2) + else if(oflag.size() > 2) { - optLevel[0] = '1'; + optLevel = oflag.substr(2); } gflag = this->ExtractFlag("-g", flags); // put back gdwarf-2 if used since there is no way @@ -2316,7 +2355,7 @@ void cmGlobalXCodeGenerator::CreateBuildSettings(cmTarget& target, // Add Fortran source format attribute if property is set. const char* format = 0; - const char* tgtfmt = target.GetProperty("Fortran_FORMAT"); + const char* tgtfmt = gtgt->GetProperty("Fortran_FORMAT"); switch(this->CurrentLocalGenerator->GetFortranFormat(tgtfmt)) { case cmLocalGenerator::FortranFormatFixed: format = "fixed"; break; @@ -2331,7 +2370,7 @@ void cmGlobalXCodeGenerator::CreateBuildSettings(cmTarget& target, // Create the INSTALL_PATH attribute. std::string install_name_dir; - if(target.GetType() == cmTarget::SHARED_LIBRARY) + if(gtgt->GetType() == cmState::SHARED_LIBRARY) { // Get the install_name directory for the build tree. install_name_dir = gtgt->GetInstallNameDirForBuildTree(configName); @@ -2393,7 +2432,7 @@ void cmGlobalXCodeGenerator::CreateBuildSettings(cmTarget& target, } } - buildSettings->AddAttribute(this->GetTargetLinkFlagsVar(target), + buildSettings->AddAttribute(this->GetTargetLinkFlagsVar(gtgt), this->CreateString(extraLinkOptions.c_str())); buildSettings->AddAttribute("OTHER_REZFLAGS", this->CreateString("")); @@ -2419,14 +2458,14 @@ void cmGlobalXCodeGenerator::CreateBuildSettings(cmTarget& target, } // Runtime version information. - if(target.GetType() == cmTarget::SHARED_LIBRARY) + if(gtgt->GetType() == cmState::SHARED_LIBRARY) { int major; int minor; int patch; // VERSION -> current_version - target.GetTargetVersion(false, major, minor, patch); + gtgt->GetTargetVersion(false, major, minor, patch); std::ostringstream v; // Xcode always wants at least 1.0.0 or nothing @@ -2438,7 +2477,7 @@ void cmGlobalXCodeGenerator::CreateBuildSettings(cmTarget& target, this->CreateString(v.str().c_str())); // SOVERSION -> compatibility_version - target.GetTargetVersion(true, major, minor, patch); + gtgt->GetTargetVersion(true, major, minor, patch); std::ostringstream vso; // Xcode always wants at least 1.0.0 or nothing @@ -2452,13 +2491,13 @@ void cmGlobalXCodeGenerator::CreateBuildSettings(cmTarget& target, // put this last so it can override existing settings // Convert "XCODE_ATTRIBUTE_*" properties directly. { - cmPropertyMap const& props = target.GetProperties(); - for(cmPropertyMap::const_iterator i = props.begin(); + std::vector<std::string> const& props = gtgt->GetPropertyKeys(); + for(std::vector<std::string>::const_iterator i = props.begin(); i != props.end(); ++i) { - if(i->first.find("XCODE_ATTRIBUTE_") == 0) + if(i->find("XCODE_ATTRIBUTE_") == 0) { - std::string attribute = i->first.substr(16); + std::string attribute = i->substr(16); // Handle [variant=<config>] condition explicitly here. std::string::size_type beginVariant = attribute.find("[variant="); @@ -2489,8 +2528,8 @@ void cmGlobalXCodeGenerator::CreateBuildSettings(cmTarget& target, if (!attribute.empty()) { cmGeneratorExpression ge; - std::string processed = ge.Parse(i->second.GetValue()) - ->Evaluate(this->CurrentMakefile, configName); + std::string processed = ge.Parse(gtgt->GetProperty(*i)) + ->Evaluate(this->CurrentLocalGenerator, configName); buildSettings->AddAttribute(attribute.c_str(), this->CreateString(processed)); } @@ -2501,7 +2540,7 @@ void cmGlobalXCodeGenerator::CreateBuildSettings(cmTarget& target, //---------------------------------------------------------------------------- cmXCodeObject* -cmGlobalXCodeGenerator::CreateUtilityTarget(cmTarget& cmtarget) +cmGlobalXCodeGenerator::CreateUtilityTarget(cmGeneratorTarget* gtgt) { cmXCodeObject* shellBuildPhase = this->CreateObject(cmXCodeObject::PBXShellScriptBuildPhase); @@ -2525,16 +2564,16 @@ cmGlobalXCodeGenerator::CreateUtilityTarget(cmTarget& cmtarget) cmXCodeObject* target = this->CreateObject(cmXCodeObject::PBXAggregateTarget); - target->SetComment(cmtarget.GetName().c_str()); + target->SetComment(gtgt->GetName().c_str()); cmXCodeObject* buildPhases = this->CreateObject(cmXCodeObject::OBJECT_LIST); std::vector<cmXCodeObject*> emptyContentVector; this->CreateCustomCommands(buildPhases, 0, 0, 0, emptyContentVector, 0, - cmtarget); + gtgt); target->AddAttribute("buildPhases", buildPhases); if(this->XcodeVersion > 20) { - this->AddConfigurations(target, cmtarget); + this->AddConfigurations(target, gtgt); } else { @@ -2542,22 +2581,21 @@ cmGlobalXCodeGenerator::CreateUtilityTarget(cmTarget& cmtarget) this->CurrentMakefile->GetSafeDefinition("CMAKE_BUILD_TYPE"); cmXCodeObject* buildSettings = this->CreateObject(cmXCodeObject::ATTRIBUTE_GROUP); - this->CreateBuildSettings(cmtarget, buildSettings, theConfig); + this->CreateBuildSettings(gtgt, buildSettings, theConfig); target->AddAttribute("buildSettings", buildSettings); } cmXCodeObject* dependencies = this->CreateObject(cmXCodeObject::OBJECT_LIST); target->AddAttribute("dependencies", dependencies); - target->AddAttribute("name", this->CreateString(cmtarget.GetName())); - target->AddAttribute("productName",this->CreateString(cmtarget.GetName())); - target->SetTarget(&cmtarget); - this->XCodeObjectMap[&cmtarget] = target; + target->AddAttribute("name", this->CreateString(gtgt->GetName())); + target->AddAttribute("productName",this->CreateString(gtgt->GetName())); + target->SetTarget(gtgt); + this->XCodeObjectMap[gtgt] = target; // Add source files without build rules for editing convenience. - if(cmtarget.GetType() == cmTarget::UTILITY) + if(gtgt->GetType() == cmState::UTILITY) { std::vector<cmSourceFile*> sources; - cmGeneratorTarget* gtgt = this->GetGeneratorTarget(&cmtarget); if (!gtgt->GetConfigCommonSourceFiles(sources)) { return 0; @@ -2568,20 +2606,20 @@ cmGlobalXCodeGenerator::CreateUtilityTarget(cmTarget& cmtarget) { if(!(*i)->GetPropertyAsBool("GENERATED")) { - this->CreateXCodeFileReference(*i, cmtarget); + this->CreateXCodeFileReference(*i, gtgt); } } } target->SetId(this->GetOrCreateId( - cmtarget.GetName(), target->GetId()).c_str()); + gtgt->GetName(), target->GetId()).c_str()); return target; } //---------------------------------------------------------------------------- std::string cmGlobalXCodeGenerator::AddConfigurations(cmXCodeObject* target, - cmTarget& cmtarget) + cmGeneratorTarget* gtgt) { std::string configTypes = this->CurrentMakefile->GetRequiredDefinition("CMAKE_CONFIGURATION_TYPES"); @@ -2597,7 +2635,7 @@ std::string cmGlobalXCodeGenerator::AddConfigurations(cmXCodeObject* target, std::string comment = "Build configuration list for "; comment += cmXCodeObject::PBXTypeNames[target->GetIsA()]; comment += " \""; - comment += cmtarget.GetName(); + comment += gtgt->GetName(); comment += "\""; configlist->SetComment(comment.c_str()); target->AddAttribute("buildConfigurationList", @@ -2609,7 +2647,7 @@ std::string cmGlobalXCodeGenerator::AddConfigurations(cmXCodeObject* target, buildConfigurations->AddObject(config); cmXCodeObject* buildSettings = this->CreateObject(cmXCodeObject::ATTRIBUTE_GROUP); - this->CreateBuildSettings(cmtarget, buildSettings, + this->CreateBuildSettings(gtgt, buildSettings, configVector[i].c_str()); config->AddAttribute("name", this->CreateString(configVector[i].c_str())); config->SetComment(configVector[i].c_str()); @@ -2627,12 +2665,12 @@ std::string cmGlobalXCodeGenerator::AddConfigurations(cmXCodeObject* target, } //---------------------------------------------------------------------------- -const char* -cmGlobalXCodeGenerator::GetTargetLinkFlagsVar(cmTarget const& cmtarget) const +const char* cmGlobalXCodeGenerator::GetTargetLinkFlagsVar( + cmGeneratorTarget const* target) const { if(this->XcodeVersion >= 60 && - (cmtarget.GetType() == cmTarget::STATIC_LIBRARY || - cmtarget.GetType() == cmTarget::OBJECT_LIBRARY)) + (target->GetType() == cmState::STATIC_LIBRARY || + target->GetType() == cmState::OBJECT_LIBRARY)) { return "OTHER_LIBTOOLFLAGS"; } @@ -2643,25 +2681,26 @@ cmGlobalXCodeGenerator::GetTargetLinkFlagsVar(cmTarget const& cmtarget) const } //---------------------------------------------------------------------------- -const char* cmGlobalXCodeGenerator::GetTargetFileType(cmTarget& cmtarget) +const char* cmGlobalXCodeGenerator::GetTargetFileType( + cmGeneratorTarget* target) { - switch(cmtarget.GetType()) + switch(target->GetType()) { - case cmTarget::OBJECT_LIBRARY: - case cmTarget::STATIC_LIBRARY: + case cmState::OBJECT_LIBRARY: + case cmState::STATIC_LIBRARY: return "archive.ar"; - case cmTarget::MODULE_LIBRARY: - if (cmtarget.IsXCTestOnApple()) + case cmState::MODULE_LIBRARY: + if (target->IsXCTestOnApple()) return "wrapper.cfbundle"; - else if (cmtarget.IsCFBundleOnApple()) + else if (target->IsCFBundleOnApple()) return "wrapper.plug-in"; else return ((this->XcodeVersion >= 22)? "compiled.mach-o.executable" : "compiled.mach-o.dylib"); - case cmTarget::SHARED_LIBRARY: - return (cmtarget.GetPropertyAsBool("FRAMEWORK")? + case cmState::SHARED_LIBRARY: + return (target->GetPropertyAsBool("FRAMEWORK")? "wrapper.framework" : "compiled.mach-o.dylib"); - case cmTarget::EXECUTABLE: + case cmState::EXECUTABLE: return "compiled.mach-o.executable"; default: break; } @@ -2669,28 +2708,29 @@ const char* cmGlobalXCodeGenerator::GetTargetFileType(cmTarget& cmtarget) } //---------------------------------------------------------------------------- -const char* cmGlobalXCodeGenerator::GetTargetProductType(cmTarget& cmtarget) +const char* cmGlobalXCodeGenerator::GetTargetProductType( + cmGeneratorTarget* target) { - switch(cmtarget.GetType()) + switch(target->GetType()) { - case cmTarget::OBJECT_LIBRARY: - case cmTarget::STATIC_LIBRARY: + case cmState::OBJECT_LIBRARY: + case cmState::STATIC_LIBRARY: return "com.apple.product-type.library.static"; - case cmTarget::MODULE_LIBRARY: - if (cmtarget.IsXCTestOnApple()) + case cmState::MODULE_LIBRARY: + if (target->IsXCTestOnApple()) return "com.apple.product-type.bundle.unit-test"; - else if (cmtarget.IsCFBundleOnApple()) + else if (target->IsCFBundleOnApple()) return "com.apple.product-type.bundle"; else return ((this->XcodeVersion >= 22)? "com.apple.product-type.tool" : "com.apple.product-type.library.dynamic"); - case cmTarget::SHARED_LIBRARY: - return (cmtarget.GetPropertyAsBool("FRAMEWORK")? + case cmState::SHARED_LIBRARY: + return (target->GetPropertyAsBool("FRAMEWORK")? "com.apple.product-type.framework" : "com.apple.product-type.library.dynamic"); - case cmTarget::EXECUTABLE: - return (cmtarget.GetPropertyAsBool("MACOSX_BUNDLE")? + case cmState::EXECUTABLE: + return (target->GetPropertyAsBool("MACOSX_BUNDLE")? "com.apple.product-type.application" : "com.apple.product-type.tool"); default: break; @@ -2700,10 +2740,10 @@ const char* cmGlobalXCodeGenerator::GetTargetProductType(cmTarget& cmtarget) //---------------------------------------------------------------------------- cmXCodeObject* -cmGlobalXCodeGenerator::CreateXCodeTarget(cmTarget& cmtarget, +cmGlobalXCodeGenerator::CreateXCodeTarget(cmGeneratorTarget* gtgt, cmXCodeObject* buildPhases) { - if(cmtarget.GetType() == cmTarget::INTERFACE_LIBRARY) + if(gtgt->GetType() == cmState::INTERFACE_LIBRARY) { return 0; } @@ -2715,67 +2755,67 @@ cmGlobalXCodeGenerator::CreateXCodeTarget(cmTarget& cmtarget, std::string defConfig; if(this->XcodeVersion > 20) { - defConfig = this->AddConfigurations(target, cmtarget); + defConfig = this->AddConfigurations(target, gtgt); } else { cmXCodeObject* buildSettings = this->CreateObject(cmXCodeObject::ATTRIBUTE_GROUP); defConfig = this->CurrentMakefile->GetSafeDefinition("CMAKE_BUILD_TYPE"); - this->CreateBuildSettings(cmtarget, buildSettings, defConfig.c_str()); + this->CreateBuildSettings(gtgt, buildSettings, defConfig.c_str()); target->AddAttribute("buildSettings", buildSettings); } cmXCodeObject* dependencies = this->CreateObject(cmXCodeObject::OBJECT_LIST); target->AddAttribute("dependencies", dependencies); - target->AddAttribute("name", this->CreateString(cmtarget.GetName())); - target->AddAttribute("productName",this->CreateString(cmtarget.GetName())); + target->AddAttribute("name", this->CreateString(gtgt->GetName())); + target->AddAttribute("productName",this->CreateString(gtgt->GetName())); cmXCodeObject* fileRef = this->CreateObject(cmXCodeObject::PBXFileReference); - if(const char* fileType = this->GetTargetFileType(cmtarget)) + if(const char* fileType = this->GetTargetFileType(gtgt)) { fileRef->AddAttribute("explicitFileType", this->CreateString(fileType)); } std::string fullName; - if(cmtarget.GetType() == cmTarget::OBJECT_LIBRARY) + if(gtgt->GetType() == cmState::OBJECT_LIBRARY) { fullName = "lib"; - fullName += cmtarget.GetName(); + fullName += gtgt->GetName(); fullName += ".a"; } else { - cmGeneratorTarget *gtgt = this->GetGeneratorTarget(&cmtarget); fullName = gtgt->GetFullName(defConfig.c_str()); } fileRef->AddAttribute("path", this->CreateString(fullName.c_str())); fileRef->AddAttribute("refType", this->CreateString("0")); fileRef->AddAttribute("sourceTree", this->CreateString("BUILT_PRODUCTS_DIR")); - fileRef->SetComment(cmtarget.GetName().c_str()); + fileRef->SetComment(gtgt->GetName().c_str()); target->AddAttribute("productReference", this->CreateObjectReference(fileRef)); - if(const char* productType = this->GetTargetProductType(cmtarget)) + if(const char* productType = this->GetTargetProductType(gtgt)) { target->AddAttribute("productType", this->CreateString(productType)); } - target->SetTarget(&cmtarget); - this->XCodeObjectMap[&cmtarget] = target; + target->SetTarget(gtgt); + this->XCodeObjectMap[gtgt] = target; target->SetId(this->GetOrCreateId( - cmtarget.GetName(), target->GetId()).c_str()); + gtgt->GetName(), target->GetId()).c_str()); return target; } //---------------------------------------------------------------------------- -cmXCodeObject* cmGlobalXCodeGenerator::FindXCodeTarget(cmTarget const* t) +cmXCodeObject* +cmGlobalXCodeGenerator::FindXCodeTarget(cmGeneratorTarget const* t) { if(!t) { return 0; } - std::map<cmTarget const*, cmXCodeObject*>::const_iterator const i = + std::map<cmGeneratorTarget const*, cmXCodeObject*>::const_iterator const i = this->XCodeObjectMap.find(t); if (i == this->XCodeObjectMap.end()) { @@ -2912,23 +2952,22 @@ void cmGlobalXCodeGenerator void cmGlobalXCodeGenerator ::AddDependAndLinkInformation(cmXCodeObject* target) { - cmTarget* cmtarget = target->GetTarget(); - if(cmtarget->GetType() == cmTarget::INTERFACE_LIBRARY) + cmGeneratorTarget* gt = target->GetTarget(); + if(!gt) { + cmSystemTools::Error("Error no target on xobject\n"); return; } - if(!cmtarget) + if(gt->GetType() == cmState::INTERFACE_LIBRARY) { - cmSystemTools::Error("Error no target on xobject\n"); return; } // Add dependencies on other CMake targets. - cmGeneratorTarget* gt = this->GetGeneratorTarget(cmtarget); TargetDependSet const& deps = this->GetTargetDirectDepends(gt); for(TargetDependSet::const_iterator i = deps.begin(); i != deps.end(); ++i) { - if(cmXCodeObject* dptarget = this->FindXCodeTarget((*i)->Target)) + if(cmXCodeObject* dptarget = this->FindXCodeTarget(*i)) { this->AddDependTarget(target, dptarget); } @@ -2948,7 +2987,7 @@ void cmGlobalXCodeGenerator std::string linkObjs; const char* sep = ""; std::vector<std::string> objs; - this->GetGeneratorTarget(cmtarget)->UseObjectLibraries(objs, ""); + gt->UseObjectLibraries(objs, ""); for(std::vector<std::string>::const_iterator oi = objs.begin(); oi != objs.end(); ++oi) { @@ -2957,20 +2996,19 @@ void cmGlobalXCodeGenerator linkObjs += this->XCodeEscapePath(oi->c_str()); } this->AppendBuildSettingAttribute( - target, this->GetTargetLinkFlagsVar(*cmtarget), + target, this->GetTargetLinkFlagsVar(gt), linkObjs.c_str(), configName); } // Skip link information for object libraries. - if(cmtarget->GetType() == cmTarget::OBJECT_LIBRARY || - cmtarget->GetType() == cmTarget::STATIC_LIBRARY) + if(gt->GetType() == cmState::OBJECT_LIBRARY || + gt->GetType() == cmState::STATIC_LIBRARY) { continue; } // Compute the link library and directory information. - cmGeneratorTarget* gtgt = this->GetGeneratorTarget(cmtarget); - cmComputeLinkInformation* pcli = gtgt->GetLinkInformation(configName); + cmComputeLinkInformation* pcli = gt->GetLinkInformation(configName); if(!pcli) { continue; @@ -3028,7 +3066,7 @@ void cmGlobalXCodeGenerator linkLibs += this->XCodeEscapePath(li->Value.c_str()); } else if (!li->Target - || li->Target->GetType() != cmTarget::INTERFACE_LIBRARY) + || li->Target->GetType() != cmState::INTERFACE_LIBRARY) { linkLibs += li->Value; } @@ -3038,7 +3076,7 @@ void cmGlobalXCodeGenerator } } this->AppendBuildSettingAttribute( - target, this->GetTargetLinkFlagsVar(*cmtarget), + target, this->GetTargetLinkFlagsVar(gt), linkLibs.c_str(), configName); } } @@ -3058,35 +3096,35 @@ bool cmGlobalXCodeGenerator::CreateGroups(cmLocalGenerator* root, } cmMakefile* mf = (*i)->GetMakefile(); std::vector<cmSourceGroup> sourceGroups = mf->GetSourceGroups(); - cmTargets &tgts = mf->GetTargets(); - for(cmTargets::iterator l = tgts.begin(); l != tgts.end(); l++) + std::vector<cmGeneratorTarget*> tgts = (*i)->GetGeneratorTargets(); + for(std::vector<cmGeneratorTarget*>::iterator l = tgts.begin(); + l != tgts.end(); l++) { - cmTarget& cmtarget = l->second; + cmGeneratorTarget* gtgt = *l; // Same skipping logic here as in CreateXCodeTargets so that we do not // end up with (empty anyhow) ALL_BUILD and XCODE_DEPEND_HELPER source // groups: // - if(cmtarget.GetType() == cmTarget::GLOBAL_TARGET) + if(gtgt->GetType() == cmState::GLOBAL_TARGET) { continue; } - if(cmtarget.GetType() == cmTarget::INTERFACE_LIBRARY) + if(gtgt->GetType() == cmState::INTERFACE_LIBRARY) { continue; } // add the soon to be generated Info.plist file as a source for a // MACOSX_BUNDLE file - if(cmtarget.GetPropertyAsBool("MACOSX_BUNDLE")) + if(gtgt->GetPropertyAsBool("MACOSX_BUNDLE")) { - std::string plist = this->ComputeInfoPListLocation(cmtarget); + std::string plist = this->ComputeInfoPListLocation(gtgt); mf->GetOrCreateSource(plist, true); - cmtarget.AddSource(plist); + gtgt->AddSource(plist); } std::vector<cmSourceFile*> classes; - cmGeneratorTarget* gtgt = this->GetGeneratorTarget(&cmtarget); if (!gtgt->GetConfigCommonSourceFiles(classes)) { return false; @@ -3101,14 +3139,14 @@ bool cmGlobalXCodeGenerator::CreateGroups(cmLocalGenerator* root, cmSourceGroup* sourceGroup = mf->FindSourceGroup(source.c_str(), sourceGroups); cmXCodeObject* pbxgroup = - this->CreateOrGetPBXGroup(cmtarget, sourceGroup); - std::string key = GetGroupMapKey(cmtarget, sf); + this->CreateOrGetPBXGroup(gtgt, sourceGroup); + std::string key = GetGroupMapKey(gtgt, sf); this->GroupMap[key] = pbxgroup; } // Put OBJECT_LIBRARY objects in proper groups: std::vector<std::string> objs; - this->GetGeneratorTarget(&cmtarget)->UseObjectLibraries(objs, ""); + gtgt->UseObjectLibraries(objs, ""); for(std::vector<std::string>::const_iterator oi = objs.begin(); oi != objs.end(); ++oi) { @@ -3116,8 +3154,8 @@ bool cmGlobalXCodeGenerator::CreateGroups(cmLocalGenerator* root, cmSourceGroup* sourceGroup = mf->FindSourceGroup(source.c_str(), sourceGroups); cmXCodeObject* pbxgroup = - this->CreateOrGetPBXGroup(cmtarget, sourceGroup); - std::string key = GetGroupMapKeyFromPath(cmtarget, source); + this->CreateOrGetPBXGroup(gtgt, sourceGroup); + std::string key = GetGroupMapKeyFromPath(gtgt, source); this->GroupMap[key] = pbxgroup; } } @@ -3148,16 +3186,16 @@ cmXCodeObject *cmGlobalXCodeGenerator //---------------------------------------------------------------------------- cmXCodeObject* cmGlobalXCodeGenerator -::CreateOrGetPBXGroup(cmTarget& cmtarget, cmSourceGroup* sg) +::CreateOrGetPBXGroup(cmGeneratorTarget* gtgt, cmSourceGroup* sg) { std::string s; std::string target; - const char *targetFolder= cmtarget.GetProperty("FOLDER"); + const char *targetFolder= gtgt->GetProperty("FOLDER"); if(targetFolder) { target = targetFolder; target += "/"; } - target += cmtarget.GetName(); + target += gtgt->GetName(); s = target + "/"; s += sg->GetFullName(); std::map<std::string, cmXCodeObject* >::iterator it = @@ -3346,7 +3384,7 @@ bool cmGlobalXCodeGenerator this->RootObject->SetComment("Project object"); std::string project_id = "PROJECT_"; - project_id += root->GetMakefile()->GetProjectName(); + project_id += root->GetProjectName(); this->RootObject->SetId(this->GetOrCreateId( project_id.c_str(), this->RootObject->GetId()).c_str()); @@ -3362,6 +3400,9 @@ bool cmGlobalXCodeGenerator group = this->CreateObject(cmXCodeObject::ATTRIBUTE_GROUP); group->AddAttribute("BuildIndependentTargetsInParallel", this->CreateString("YES")); + std::ostringstream v; + v << std::setfill('0') << std::setw(4) << XcodeVersion * 10; + group->AddAttribute("LastUpgradeCheck", this->CreateString(v.str())); this->RootObject->AddAttribute("attributes", group); if (this->XcodeVersion >= 32) this->RootObject->AddAttribute("compatibilityVersion", @@ -3376,7 +3417,7 @@ bool cmGlobalXCodeGenerator // Point Xcode at the top of the source tree. { std::string pdir = - this->RelativeToBinary(root->GetMakefile()->GetCurrentSourceDirectory()); + this->RelativeToBinary(root->GetCurrentSourceDirectory()); this->RootObject->AddAttribute("projectDirPath", this->CreateString(pdir.c_str())); this->RootObject->AddAttribute("projectRoot", this->CreateString("")); @@ -3488,7 +3529,7 @@ bool cmGlobalXCodeGenerator } } - std::string symroot = root->GetMakefile()->GetCurrentBinaryDirectory(); + std::string symroot = root->GetCurrentBinaryDirectory(); symroot += "/build"; buildSettings->AddAttribute("SYMROOT", this->CreateString(symroot.c_str())); @@ -3547,10 +3588,10 @@ std::string cmGlobalXCodeGenerator::GetObjectsNormalDirectory( const std::string &projName, const std::string &configName, - const cmTarget *t) const + const cmGeneratorTarget *t) const { std::string dir = - t->GetMakefile()->GetCurrentBinaryDirectory(); + t->GetLocalGenerator()->GetCurrentBinaryDirectory(); dir += "/"; dir += projName; dir += ".build/"; @@ -3624,24 +3665,23 @@ cmGlobalXCodeGenerator::CreateXCodeDependHackTarget( i != targets.end(); ++i) { cmXCodeObject* target = *i; - cmTarget* t =target->GetTarget(); - cmGeneratorTarget *gt = this->GetGeneratorTarget(t); + cmGeneratorTarget* gt =target->GetTarget(); - if(t->GetType() == cmTarget::EXECUTABLE || + if(gt->GetType() == cmState::EXECUTABLE || // Nope - no post-build for OBJECT_LIRBRARY -// t->GetType() == cmTarget::OBJECT_LIBRARY || - t->GetType() == cmTarget::STATIC_LIBRARY || - t->GetType() == cmTarget::SHARED_LIBRARY || - t->GetType() == cmTarget::MODULE_LIBRARY) +// gt->GetType() == cmState::OBJECT_LIBRARY || + gt->GetType() == cmState::STATIC_LIBRARY || + gt->GetType() == cmState::SHARED_LIBRARY || + gt->GetType() == cmState::MODULE_LIBRARY) { // Declare an entry point for the target post-build phase. - makefileStream << this->PostBuildMakeTarget(t->GetName(), *ct) + makefileStream << this->PostBuildMakeTarget(gt->GetName(), *ct) << ":\n"; } - if(t->GetType() == cmTarget::EXECUTABLE || - t->GetType() == cmTarget::SHARED_LIBRARY || - t->GetType() == cmTarget::MODULE_LIBRARY) + if(gt->GetType() == cmState::EXECUTABLE || + gt->GetType() == cmState::SHARED_LIBRARY || + gt->GetType() == cmState::MODULE_LIBRARY) { std::string tfull = gt->GetFullPath(configName); std::string trel = this->ConvertToRelativeForMake(tfull.c_str()); @@ -3686,7 +3726,7 @@ cmGlobalXCodeGenerator::CreateXCodeDependHackTarget( if(this->Architectures.size() > 1) { std::string universal = this->GetObjectsNormalDirectory( - this->CurrentProject, configName, t); + this->CurrentProject, configName, gt); for( std::vector<std::string>::iterator arch = this->Architectures.begin(); arch != this->Architectures.end(); ++arch) @@ -3731,9 +3771,9 @@ cmGlobalXCodeGenerator::OutputXCodeProject(cmLocalGenerator* root, { return; } - std::string xcodeDir = root->GetMakefile()->GetCurrentBinaryDirectory(); + std::string xcodeDir = root->GetCurrentBinaryDirectory(); xcodeDir += "/"; - xcodeDir += root->GetMakefile()->GetProjectName(); + xcodeDir += root->GetProjectName(); xcodeDir += ".xcode"; if(this->XcodeVersion > 20) { @@ -3753,7 +3793,7 @@ cmGlobalXCodeGenerator::OutputXCodeProject(cmLocalGenerator* root, // Since this call may have created new cache entries, save the cache: // root->GetMakefile()->GetCMakeInstance()->SaveCache( - root->GetMakefile()->GetHomeOutputDirectory()); + root->GetBinaryDirectory()); } //---------------------------------------------------------------------------- @@ -4029,12 +4069,13 @@ void cmGlobalXCodeGenerator::AppendFlag(std::string& flags, //---------------------------------------------------------------------------- std::string -cmGlobalXCodeGenerator::ComputeInfoPListLocation(cmTarget& target) +cmGlobalXCodeGenerator::ComputeInfoPListLocation(cmGeneratorTarget* target) { - std::string plist = target.GetMakefile()->GetCurrentBinaryDirectory(); + std::string plist = + target->GetLocalGenerator()->GetCurrentBinaryDirectory(); plist += cmake::GetCMakeFilesDirectory(); plist += "/"; - plist += target.GetName(); + plist += target->GetName(); plist += ".dir/Info.plist"; return plist; } @@ -4060,7 +4101,7 @@ void cmGlobalXCodeGenerator { std::string configName = this->GetCMakeCFGIntDir(); std::string dir = this->GetObjectsNormalDirectory( - "$(PROJECT_NAME)", configName, gt->Target); + "$(PROJECT_NAME)", configName, gt); if(this->XcodeVersion >= 21) { dir += "$(CURRENT_ARCH)/"; diff --git a/Source/cmGlobalXCodeGenerator.h b/Source/cmGlobalXCodeGenerator.h index 102c036..c8a39df 100644 --- a/Source/cmGlobalXCodeGenerator.h +++ b/Source/cmGlobalXCodeGenerator.h @@ -16,7 +16,6 @@ #include "cmXCodeObject.h" #include "cmCustomCommand.h" class cmGlobalGeneratorFactory; -class cmTarget; class cmSourceFile; class cmSourceGroup; @@ -87,10 +86,10 @@ public: virtual bool SetGeneratorToolset(std::string const& ts, cmMakefile* mf); void AppendFlag(std::string& flags, std::string const& flag); protected: - virtual bool Compute(); + virtual void AddExtraIDETargets(); virtual void Generate(); private: - cmXCodeObject* CreateOrGetPBXGroup(cmTarget& cmtarget, + cmXCodeObject* CreateOrGetPBXGroup(cmGeneratorTarget* gtgt, cmSourceGroup* sg); cmXCodeObject* CreatePBXGroup(cmXCodeObject *parent, std::string name); @@ -108,22 +107,22 @@ private: cmXCodeObject* resourceBuildPhase, std::vector<cmXCodeObject*> contentBuildPhases, cmXCodeObject* frameworkBuildPhase, - cmTarget& cmtarget); + cmGeneratorTarget *gtgt); - std::string ComputeInfoPListLocation(cmTarget& target); + std::string ComputeInfoPListLocation(cmGeneratorTarget *target); void AddCommandsToBuildPhase(cmXCodeObject* buildphase, - cmTarget& target, + cmGeneratorTarget *target, std::vector<cmCustomCommand> const & commands, const char* commandFileName); void CreateCustomRulesMakefile(const char* makefileBasename, - cmTarget& target, + cmGeneratorTarget* target, std::vector<cmCustomCommand> const & commands, const std::string& configName); - cmXCodeObject* FindXCodeTarget(cmTarget const*); + cmXCodeObject* FindXCodeTarget(const cmGeneratorTarget *); std::string GetOrCreateId(const std::string& name, const std::string& id); // create cmXCodeObject from these functions so that memory can be managed @@ -132,25 +131,28 @@ private: cmXCodeObject* CreateObject(cmXCodeObject::Type type); cmXCodeObject* CreateString(const std::string& s); cmXCodeObject* CreateObjectReference(cmXCodeObject*); - cmXCodeObject* CreateXCodeTarget(cmTarget& target, + cmXCodeObject* CreateXCodeTarget(cmGeneratorTarget *gtgt, cmXCodeObject* buildPhases); void ForceLinkerLanguages(); - void ForceLinkerLanguage(cmTarget& cmtarget); - const char* GetTargetLinkFlagsVar(cmTarget const& cmtarget) const; - const char* GetTargetFileType(cmTarget& cmtarget); - const char* GetTargetProductType(cmTarget& cmtarget); - std::string AddConfigurations(cmXCodeObject* target, cmTarget& cmtarget); + void ForceLinkerLanguage(cmGeneratorTarget* gtgt); + const char* GetTargetLinkFlagsVar(const cmGeneratorTarget *target) const; + const char* GetTargetFileType(cmGeneratorTarget* target); + const char* GetTargetProductType(cmGeneratorTarget* target); + std::string AddConfigurations(cmXCodeObject* target, + cmGeneratorTarget *gtgt); void AppendOrAddBuildSetting(cmXCodeObject* settings, const char* attr, const char* value); void AppendBuildSettingAttribute(cmXCodeObject* target, const char* attr, const char* value, const std::string& configName); - cmXCodeObject* CreateUtilityTarget(cmTarget& target); + cmXCodeObject* CreateUtilityTarget(cmGeneratorTarget *gtgt); void AddDependAndLinkInformation(cmXCodeObject* target); - void CreateBuildSettings(cmTarget& target, + void CreateBuildSettings(cmGeneratorTarget *gtgt, cmXCodeObject* buildSettings, const std::string& buildType); std::string ExtractFlag(const char* flag, std::string& flags); + std::string ExtractFlagRegex(const char* exp, int matchIndex, + std::string& flags); void SortXCodeObjects(); // delete all objects in the this->XCodeObjects vector. void ClearXCodeObjects(); @@ -161,18 +163,18 @@ private: void WriteXCodePBXProj(std::ostream& fout, cmLocalGenerator* root, std::vector<cmLocalGenerator*>& generators); cmXCodeObject* CreateXCodeFileReferenceFromPath(const std::string &fullpath, - cmTarget& cmtarget, + cmGeneratorTarget *target, const std::string &lang, cmSourceFile* sf); cmXCodeObject* CreateXCodeSourceFileFromPath(const std::string &fullpath, - cmTarget& cmtarget, + cmGeneratorTarget *target, const std::string &lang, cmSourceFile* sf); cmXCodeObject* CreateXCodeFileReference(cmSourceFile* sf, - cmTarget& cmtarget); + cmGeneratorTarget *target); cmXCodeObject* CreateXCodeSourceFile(cmLocalGenerator* gen, cmSourceFile* sf, - cmTarget& cmtarget); + cmGeneratorTarget *gtgt); bool CreateXCodeTargets(cmLocalGenerator* gen, std::vector<cmXCodeObject*>&); bool IsHeaderFile(cmSourceFile*); @@ -185,7 +187,7 @@ private: std::vector<cmLocalGenerator*>& gens); cmXCodeObject* CreateBuildPhase(const char* name, const char* name2, - cmTarget& cmtarget, + cmGeneratorTarget *target, const std::vector<cmCustomCommand>&); void CreateReRunCMakeFile(cmLocalGenerator* root, std::vector<cmLocalGenerator*> const& gens); @@ -224,10 +226,9 @@ private: void PrintCompilerAdvice(std::ostream&, std::string const&, const char*) const {} - std::string GetObjectsNormalDirectory( - const std::string &projName, + std::string GetObjectsNormalDirectory(const std::string &projName, const std::string &configName, - const cmTarget *t) const; + const cmGeneratorTarget *t) const; void addObject(cmXCodeObject *obj); std::string PostBuildMakeTarget(std::string const& tName, @@ -249,7 +250,7 @@ private: std::map<std::string, cmXCodeObject* > GroupNameMap; std::map<std::string, cmXCodeObject* > TargetGroup; std::map<std::string, cmXCodeObject* > FileRefs; - std::map<cmTarget const*, cmXCodeObject* > XCodeObjectMap; + std::map<cmGeneratorTarget const*, cmXCodeObject* > XCodeObjectMap; std::vector<std::string> Architectures; std::string GeneratorToolset; }; diff --git a/Source/cmGraphVizWriter.cxx b/Source/cmGraphVizWriter.cxx index 2023697..a63b6e3 100644 --- a/Source/cmGraphVizWriter.cxx +++ b/Source/cmGraphVizWriter.cxx @@ -17,7 +17,7 @@ -static const char* getShapeForTarget(const cmTarget* target) +static const char* getShapeForTarget(const cmGeneratorTarget* target) { if (!target) { @@ -26,13 +26,13 @@ static const char* getShapeForTarget(const cmTarget* target) switch ( target->GetType() ) { - case cmTarget::EXECUTABLE: + case cmState::EXECUTABLE: return "house"; - case cmTarget::STATIC_LIBRARY: + case cmState::STATIC_LIBRARY: return "diamond"; - case cmTarget::SHARED_LIBRARY: + case cmState::SHARED_LIBRARY: return "polygon"; - case cmTarget::MODULE_LIBRARY: + case cmState::MODULE_LIBRARY: return "octagon"; default: break; @@ -67,6 +67,7 @@ void cmGraphVizWriter::ReadSettings(const char* settingsFileName, cmake cm; cm.SetHomeDirectory(""); cm.SetHomeOutputDirectory(""); + cm.GetCurrentSnapshot().SetDefaultDefinitions(); cmGlobalGenerator ggi(&cm); cmsys::auto_ptr<cmMakefile> mf( new cmMakefile(&ggi, cm.GetCurrentSnapshot())); @@ -162,7 +163,7 @@ void cmGraphVizWriter::WriteTargetDependersFiles(const char* fileName) this->CollectTargetsAndLibs(); - for(std::map<std::string, const cmTarget*>::const_iterator ptrIt = + for(std::map<std::string, const cmGeneratorTarget*>::const_iterator ptrIt = this->TargetPtrs.begin(); ptrIt != this->TargetPtrs.end(); ++ptrIt) @@ -213,7 +214,7 @@ void cmGraphVizWriter::WritePerTargetFiles(const char* fileName) this->CollectTargetsAndLibs(); - for(std::map<std::string, const cmTarget*>::const_iterator ptrIt = + for(std::map<std::string, const cmGeneratorTarget*>::const_iterator ptrIt = this->TargetPtrs.begin(); ptrIt != this->TargetPtrs.end(); ++ptrIt) @@ -267,7 +268,7 @@ void cmGraphVizWriter::WriteGlobalFile(const char* fileName) std::set<std::string> insertedConnections; std::set<std::string> insertedNodes; - for(std::map<std::string, const cmTarget*>::const_iterator ptrIt = + for(std::map<std::string, const cmGeneratorTarget*>::const_iterator ptrIt = this->TargetPtrs.begin(); ptrIt != this->TargetPtrs.end(); ++ptrIt) @@ -307,8 +308,8 @@ void cmGraphVizWriter::WriteConnections(const std::string& targetName, std::set<std::string>& insertedConnections, cmGeneratedFileStream& str) const { - std::map<std::string, const cmTarget* >::const_iterator targetPtrIt = - this->TargetPtrs.find(targetName); + std::map<std::string, const cmGeneratorTarget* >::const_iterator targetPtrIt + = this->TargetPtrs.find(targetName); if (targetPtrIt == this->TargetPtrs.end()) // not found at all { @@ -326,7 +327,7 @@ void cmGraphVizWriter::WriteConnections(const std::string& targetName, std::string myNodeName = this->TargetNamesNodes.find(targetName)->second; const cmTarget::LinkLibraryVectorType* ll = - &(targetPtrIt->second->GetOriginalLinkLibraries()); + &(targetPtrIt->second->Target->GetOriginalLinkLibraries()); for (cmTarget::LinkLibraryVectorType::const_iterator llit = ll->begin(); llit != ll->end(); @@ -366,8 +367,8 @@ void cmGraphVizWriter::WriteDependerConnections(const std::string& targetName, std::set<std::string>& insertedConnections, cmGeneratedFileStream& str) const { - std::map<std::string, const cmTarget* >::const_iterator targetPtrIt = - this->TargetPtrs.find(targetName); + std::map<std::string, const cmGeneratorTarget* >::const_iterator targetPtrIt + = this->TargetPtrs.find(targetName); if (targetPtrIt == this->TargetPtrs.end()) // not found at all { @@ -385,8 +386,8 @@ void cmGraphVizWriter::WriteDependerConnections(const std::string& targetName, std::string myNodeName = this->TargetNamesNodes.find(targetName)->second; // now search who links against me - for(std::map<std::string, const cmTarget*>::const_iterator dependerIt = - this->TargetPtrs.begin(); + for(std::map<std::string, const cmGeneratorTarget*>::const_iterator + dependerIt = this->TargetPtrs.begin(); dependerIt != this->TargetPtrs.end(); ++dependerIt) { @@ -403,7 +404,7 @@ void cmGraphVizWriter::WriteDependerConnections(const std::string& targetName, // Now we have a target, check whether it links against targetName. // If so, draw a connection, and then continue with dependers on that one. const cmTarget::LinkLibraryVectorType* ll = - &(dependerIt->second->GetOriginalLinkLibraries()); + &(dependerIt->second->Target->GetOriginalLinkLibraries()); for (cmTarget::LinkLibraryVectorType::const_iterator llit = ll->begin(); llit != ll->end(); @@ -447,7 +448,7 @@ void cmGraphVizWriter::WriteDependerConnections(const std::string& targetName, void cmGraphVizWriter::WriteNode(const std::string& targetName, - const cmTarget* target, + const cmGeneratorTarget* target, std::set<std::string>& insertedNodes, cmGeneratedFileStream& str) const { @@ -487,12 +488,11 @@ int cmGraphVizWriter::CollectAllTargets() lit != this->LocalGenerators.end(); ++ lit ) { - const cmTargets* targets = &((*lit)->GetMakefile()->GetTargets()); - for ( cmTargets::const_iterator tit = targets->begin(); - tit != targets->end(); - ++ tit ) + std::vector<cmGeneratorTarget*> targets = (*lit)->GetGeneratorTargets(); + for ( std::vector<cmGeneratorTarget*>::const_iterator it = + targets.begin(); it != targets.end(); ++it ) { - const char* realTargetName = tit->first.c_str(); + const char* realTargetName = (*it)->GetName().c_str(); if(this->IgnoreThisTarget(realTargetName)) { // Skip ignored targets @@ -502,7 +502,7 @@ int cmGraphVizWriter::CollectAllTargets() std::ostringstream ostr; ostr << this->GraphNodePrefix << cnt++; this->TargetNamesNodes[realTargetName] = ostr.str(); - this->TargetPtrs[realTargetName] = &tit->second; + this->TargetPtrs[realTargetName] = *it; } } @@ -518,19 +518,18 @@ int cmGraphVizWriter::CollectAllExternalLibs(int cnt) lit != this->LocalGenerators.end(); ++ lit ) { - const cmTargets* targets = &((*lit)->GetMakefile()->GetTargets()); - for ( cmTargets::const_iterator tit = targets->begin(); - tit != targets->end(); - ++ tit ) + std::vector<cmGeneratorTarget*> targets = (*lit)->GetGeneratorTargets(); + for ( std::vector<cmGeneratorTarget*>::const_iterator it = + targets.begin(); it != targets.end(); ++it ) { - const char* realTargetName = tit->first.c_str(); + const char* realTargetName = (*it)->GetName().c_str(); if (this->IgnoreThisTarget(realTargetName)) { // Skip ignored targets continue; } const cmTarget::LinkLibraryVectorType* ll = - &(tit->second.GetOriginalLinkLibraries()); + &((*it)->Target->GetOriginalLinkLibraries()); for (cmTarget::LinkLibraryVectorType::const_iterator llit = ll->begin(); llit != ll->end(); ++ llit ) @@ -542,8 +541,8 @@ int cmGraphVizWriter::CollectAllExternalLibs(int cnt) continue; } - std::map<std::string, const cmTarget*>::const_iterator tarIt = - this->TargetPtrs.find(libName); + std::map<std::string, const cmGeneratorTarget*>::const_iterator tarIt + = this->TargetPtrs.find(libName); if ( tarIt == this->TargetPtrs.end() ) { std::ostringstream ostr; @@ -581,18 +580,18 @@ bool cmGraphVizWriter::IgnoreThisTarget(const std::string& name) } -bool cmGraphVizWriter::GenerateForTargetType(cmTarget::TargetType targetType) +bool cmGraphVizWriter::GenerateForTargetType(cmState::TargetType targetType) const { switch (targetType) { - case cmTarget::EXECUTABLE: + case cmState::EXECUTABLE: return this->GenerateForExecutables; - case cmTarget::STATIC_LIBRARY: + case cmState::STATIC_LIBRARY: return this->GenerateForStaticLibs; - case cmTarget::SHARED_LIBRARY: + case cmState::SHARED_LIBRARY: return this->GenerateForSharedLibs; - case cmTarget::MODULE_LIBRARY: + case cmState::MODULE_LIBRARY: return this->GenerateForModuleLibs; default: break; diff --git a/Source/cmGraphVizWriter.h b/Source/cmGraphVizWriter.h index 64de684..90d31d3 100644 --- a/Source/cmGraphVizWriter.h +++ b/Source/cmGraphVizWriter.h @@ -14,9 +14,9 @@ #include "cmStandardIncludes.h" #include "cmLocalGenerator.h" #include "cmGeneratedFileStream.h" -#include "cmTarget.h" #include <cmsys/RegularExpression.hxx> +class cmGeneratorTarget; /** This class implements writing files for graphviz (dot) for graphs * representing the dependencies between the targets in the project. */ @@ -54,7 +54,8 @@ protected: std::set<std::string>& insertedConnections, cmGeneratedFileStream& str) const; - void WriteNode(const std::string& targetName, const cmTarget* target, + void WriteNode(const std::string& targetName, + const cmGeneratorTarget* target, std::set<std::string>& insertedNodes, cmGeneratedFileStream& str) const; @@ -62,7 +63,7 @@ protected: bool IgnoreThisTarget(const std::string& name); - bool GenerateForTargetType(cmTarget::TargetType targetType) const; + bool GenerateForTargetType(cmState::TargetType targetType) const; std::string GraphType; std::string GraphName; @@ -73,7 +74,7 @@ protected: const std::vector<cmLocalGenerator*>& LocalGenerators; - std::map<std::string, const cmTarget*> TargetPtrs; + std::map<std::string, const cmGeneratorTarget*> TargetPtrs; // maps from the actual target names to node names in dot: std::map<std::string, std::string> TargetNamesNodes; diff --git a/Source/cmIfCommand.cxx b/Source/cmIfCommand.cxx index 9e71d37..5964ef1 100644 --- a/Source/cmIfCommand.cxx +++ b/Source/cmIfCommand.cxx @@ -11,6 +11,7 @@ ============================================================================*/ #include "cmIfCommand.h" #include "cmStringCommand.h" +#include "cmOutputConverter.h" #include "cmConditionEvaluator.h" diff --git a/Source/cmIncludeExternalMSProjectCommand.cxx b/Source/cmIncludeExternalMSProjectCommand.cxx index 1e7258a..c64d128 100644 --- a/Source/cmIncludeExternalMSProjectCommand.cxx +++ b/Source/cmIncludeExternalMSProjectCommand.cxx @@ -77,7 +77,7 @@ bool cmIncludeExternalMSProjectCommand } // Create a target instance for this utility. - cmTarget* target=this->Makefile->AddNewTarget(cmTarget::UTILITY, + cmTarget* target=this->Makefile->AddNewTarget(cmState::UTILITY, utility_name.c_str()); target->SetProperty("GENERATOR_FILE_NAME", utility_name.c_str()); diff --git a/Source/cmInstallCommand.cxx b/Source/cmInstallCommand.cxx index d3c2e26..15a83ee 100644 --- a/Source/cmInstallCommand.cxx +++ b/Source/cmInstallCommand.cxx @@ -384,12 +384,12 @@ bool cmInstallCommand::HandleTargetsMode(std::vector<std::string> const& args) if(cmTarget* target=this->Makefile->FindTarget(*targetIt)) { // Found the target. Check its type. - if(target->GetType() != cmTarget::EXECUTABLE && - target->GetType() != cmTarget::STATIC_LIBRARY && - target->GetType() != cmTarget::SHARED_LIBRARY && - target->GetType() != cmTarget::MODULE_LIBRARY && - target->GetType() != cmTarget::OBJECT_LIBRARY && - target->GetType() != cmTarget::INTERFACE_LIBRARY) + if(target->GetType() != cmState::EXECUTABLE && + target->GetType() != cmState::STATIC_LIBRARY && + target->GetType() != cmState::SHARED_LIBRARY && + target->GetType() != cmState::MODULE_LIBRARY && + target->GetType() != cmState::OBJECT_LIBRARY && + target->GetType() != cmState::INTERFACE_LIBRARY) { std::ostringstream e; e << "TARGETS given target \"" << (*targetIt) @@ -397,7 +397,7 @@ bool cmInstallCommand::HandleTargetsMode(std::vector<std::string> const& args) this->SetError(e.str()); return false; } - else if(target->GetType() == cmTarget::OBJECT_LIBRARY) + else if(target->GetType() == cmState::OBJECT_LIBRARY) { std::ostringstream e; e << "TARGETS given OBJECT library \"" << (*targetIt) @@ -450,7 +450,7 @@ bool cmInstallCommand::HandleTargetsMode(std::vector<std::string> const& args) switch(target.GetType()) { - case cmTarget::SHARED_LIBRARY: + case cmState::SHARED_LIBRARY: { // Shared libraries are handled differently on DLL and non-DLL // platforms. All windows platforms are DLL platforms including @@ -533,7 +533,7 @@ bool cmInstallCommand::HandleTargetsMode(std::vector<std::string> const& args) } } break; - case cmTarget::STATIC_LIBRARY: + case cmState::STATIC_LIBRARY: { // Static libraries use ARCHIVE properties. if (!archiveArgs.GetDestination().empty()) @@ -551,7 +551,7 @@ bool cmInstallCommand::HandleTargetsMode(std::vector<std::string> const& args) } } break; - case cmTarget::MODULE_LIBRARY: + case cmState::MODULE_LIBRARY: { // Modules use LIBRARY properties. if (!libraryArgs.GetDestination().empty()) @@ -572,7 +572,7 @@ bool cmInstallCommand::HandleTargetsMode(std::vector<std::string> const& args) } } break; - case cmTarget::EXECUTABLE: + case cmState::EXECUTABLE: { if(target.IsAppBundleOnApple()) { @@ -636,7 +636,7 @@ bool cmInstallCommand::HandleTargetsMode(std::vector<std::string> const& args) } } break; - case cmTarget::INTERFACE_LIBRARY: + case cmState::INTERFACE_LIBRARY: // Nothing to do. An INTERFACE_LIBRARY can be installed, but the // only effect of that is to make it exportable. It installs no // other files itself. @@ -655,7 +655,7 @@ bool cmInstallCommand::HandleTargetsMode(std::vector<std::string> const& args) bool createInstallGeneratorsForTargetFileSets = true; if(target.IsFrameworkOnApple() - || target.GetType() == cmTarget::INTERFACE_LIBRARY) + || target.GetType() == cmState::INTERFACE_LIBRARY) { createInstallGeneratorsForTargetFileSets = false; } @@ -768,7 +768,7 @@ bool cmInstallCommand::HandleTargetsMode(std::vector<std::string> const& args) if(!exports.GetString().empty() && !namelinkOnly) { cmTargetExport *te = new cmTargetExport; - te->Target = ⌖ + te->TargetName = target.GetName(); te->ArchiveGenerator = archiveGenerator; te->BundleGenerator = bundleGenerator; te->FrameworkGenerator = frameworkGenerator; @@ -1374,16 +1374,17 @@ bool cmInstallCommand::HandleExportMode(std::vector<std::string> const& args) tei != exportSet->GetTargetExports()->end(); ++tei) { cmTargetExport const* te = *tei; + cmTarget* tgt = this->Makefile->FindTarget(te->TargetName); const bool newCMP0022Behavior = - te->Target->GetPolicyStatusCMP0022() != cmPolicies::WARN - && te->Target->GetPolicyStatusCMP0022() != cmPolicies::OLD; + tgt->GetPolicyStatusCMP0022() != cmPolicies::WARN + && tgt->GetPolicyStatusCMP0022() != cmPolicies::OLD; if(!newCMP0022Behavior) { std::ostringstream e; e << "INSTALL(EXPORT) given keyword \"" << "EXPORT_LINK_INTERFACE_LIBRARIES" << "\", but target \"" - << te->Target->GetName() + << te->TargetName << "\" does not have policy CMP0022 set to NEW."; this->SetError(e.str()); return false; diff --git a/Source/cmInstallDirectoryGenerator.cxx b/Source/cmInstallDirectoryGenerator.cxx index 78cb5f0..ea27f61 100644 --- a/Source/cmInstallDirectoryGenerator.cxx +++ b/Source/cmInstallDirectoryGenerator.cxx @@ -11,7 +11,6 @@ ============================================================================*/ #include "cmInstallDirectoryGenerator.h" -#include "cmTarget.h" #include "cmGeneratorExpression.h" #include "cmLocalGenerator.h" @@ -97,5 +96,5 @@ cmInstallDirectoryGenerator::GetDestination(std::string const& config) const { cmGeneratorExpression ge; return ge.Parse(this->Destination) - ->Evaluate(this->LocalGenerator->GetMakefile(), config); + ->Evaluate(this->LocalGenerator, config); } diff --git a/Source/cmInstallExportGenerator.cxx b/Source/cmInstallExportGenerator.cxx index 97b9405..9570ba3 100644 --- a/Source/cmInstallExportGenerator.cxx +++ b/Source/cmInstallExportGenerator.cxx @@ -56,6 +56,7 @@ cmInstallExportGenerator::~cmInstallExportGenerator() void cmInstallExportGenerator::Compute(cmLocalGenerator* lg) { this->LocalGenerator = lg; + this->ExportSet->Compute(lg); } //---------------------------------------------------------------------------- @@ -64,7 +65,7 @@ void cmInstallExportGenerator::ComputeTempDir() // Choose a temporary directory in which to generate the import // files to be installed. this->TempDir = - this->LocalGenerator->GetMakefile()->GetCurrentBinaryDirectory(); + this->LocalGenerator->GetCurrentBinaryDirectory(); this->TempDir += cmake::GetCMakeFilesDirectory(); this->TempDir += "/Export"; if(this->Destination.empty()) diff --git a/Source/cmInstallFilesGenerator.cxx b/Source/cmInstallFilesGenerator.cxx index e2c16c8..383031b 100644 --- a/Source/cmInstallFilesGenerator.cxx +++ b/Source/cmInstallFilesGenerator.cxx @@ -68,7 +68,7 @@ cmInstallFilesGenerator::GetDestination(std::string const& config) const { cmGeneratorExpression ge; return ge.Parse(this->Destination) - ->Evaluate(this->LocalGenerator->GetMakefile(), config); + ->Evaluate(this->LocalGenerator, config); } //---------------------------------------------------------------------------- @@ -117,7 +117,7 @@ void cmInstallFilesGenerator::GenerateScriptForConfig(std::ostream& os, { cmsys::auto_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(*i); cmSystemTools::ExpandListArgument(cge->Evaluate( - this->LocalGenerator->GetMakefile(), config), files); + this->LocalGenerator, config), files); } this->AddFilesInstallRule(os, config, indent, files); } diff --git a/Source/cmInstallTargetGenerator.cxx b/Source/cmInstallTargetGenerator.cxx index 30cf175..59d06f6 100644 --- a/Source/cmInstallTargetGenerator.cxx +++ b/Source/cmInstallTargetGenerator.cxx @@ -76,14 +76,14 @@ void cmInstallTargetGenerator::GenerateScriptForConfig(std::ostream& os, if(this->Target->NeedRelinkBeforeInstall(config)) { fromDirConfig = - this->Target->Target->GetMakefile()->GetCurrentBinaryDirectory(); + this->Target->GetLocalGenerator()->GetCurrentBinaryDirectory(); fromDirConfig += cmake::GetCMakeFilesDirectory(); fromDirConfig += "/CMakeRelink.dir/"; } else { fromDirConfig = - this->Target->Target->GetDirectory(config, this->ImportLibrary); + this->Target->GetDirectory(config, this->ImportLibrary); fromDirConfig += "/"; } std::string toDir = @@ -94,29 +94,28 @@ void cmInstallTargetGenerator::GenerateScriptForConfig(std::ostream& os, std::vector<std::string> filesFrom; std::vector<std::string> filesTo; std::string literal_args; - cmTarget::TargetType targetType = - static_cast<cmTarget::TargetType>(this->Target->GetType()); + cmState::TargetType targetType = this->Target->GetType(); cmInstallType type = cmInstallType(); switch(targetType) { - case cmTarget::EXECUTABLE: type = cmInstallType_EXECUTABLE; break; - case cmTarget::STATIC_LIBRARY: type = cmInstallType_STATIC_LIBRARY; break; - case cmTarget::SHARED_LIBRARY: type = cmInstallType_SHARED_LIBRARY; break; - case cmTarget::MODULE_LIBRARY: type = cmInstallType_MODULE_LIBRARY; break; - case cmTarget::INTERFACE_LIBRARY: + case cmState::EXECUTABLE: type = cmInstallType_EXECUTABLE; break; + case cmState::STATIC_LIBRARY: type = cmInstallType_STATIC_LIBRARY; break; + case cmState::SHARED_LIBRARY: type = cmInstallType_SHARED_LIBRARY; break; + case cmState::MODULE_LIBRARY: type = cmInstallType_MODULE_LIBRARY; break; + case cmState::INTERFACE_LIBRARY: // Not reachable. We never create a cmInstallTargetGenerator for // an INTERFACE_LIBRARY. assert(0 && "INTERFACE_LIBRARY targets have no installable outputs."); break; - case cmTarget::OBJECT_LIBRARY: - case cmTarget::UTILITY: - case cmTarget::GLOBAL_TARGET: - case cmTarget::UNKNOWN_LIBRARY: - this->Target->Target->GetMakefile()->IssueMessage(cmake::INTERNAL_ERROR, + case cmState::OBJECT_LIBRARY: + case cmState::UTILITY: + case cmState::GLOBAL_TARGET: + case cmState::UNKNOWN_LIBRARY: + this->Target->GetLocalGenerator()->IssueMessage(cmake::INTERNAL_ERROR, "cmInstallTargetGenerator created with non-installable target."); return; } - if(targetType == cmTarget::EXECUTABLE) + if(targetType == cmState::EXECUTABLE) { // There is a bug in cmInstallCommand if this fails. assert(this->NamelinkMode == NamelinkModeNone); @@ -135,7 +134,7 @@ void cmInstallTargetGenerator::GenerateScriptForConfig(std::ostream& os, filesFrom.push_back(from1); filesTo.push_back(to1); std::string targetNameImportLib; - if(this->Target->Target->GetImplibGNUtoMS(targetNameImport, + if(this->Target->GetImplibGNUtoMS(targetNameImport, targetNameImportLib)) { filesFrom.push_back(fromDirConfig + targetNameImportLib); @@ -151,7 +150,7 @@ void cmInstallTargetGenerator::GenerateScriptForConfig(std::ostream& os, std::string to1 = toDir + targetName; // Handle OSX Bundles. - if(this->Target->Target->IsAppBundleOnApple()) + if(this->Target->IsAppBundleOnApple()) { // Install the whole app bundle directory. type = cmInstallType_DIRECTORY; @@ -199,7 +198,7 @@ void cmInstallTargetGenerator::GenerateScriptForConfig(std::ostream& os, filesFrom.push_back(from1); filesTo.push_back(to1); std::string targetNameImportLib; - if(this->Target->Target->GetImplibGNUtoMS(targetNameImport, + if(this->Target->GetImplibGNUtoMS(targetNameImport, targetNameImportLib)) { filesFrom.push_back(fromDirConfig + targetNameImportLib); @@ -209,7 +208,7 @@ void cmInstallTargetGenerator::GenerateScriptForConfig(std::ostream& os, // An import library looks like a static library. type = cmInstallType_STATIC_LIBRARY; } - else if(this->Target->Target->IsFrameworkOnApple()) + else if(this->Target->IsFrameworkOnApple()) { // There is a bug in cmInstallCommand if this fails. assert(this->NamelinkMode == NamelinkModeNone); @@ -227,7 +226,7 @@ void cmInstallTargetGenerator::GenerateScriptForConfig(std::ostream& os, filesFrom.push_back(from1); filesTo.push_back(to1); } - else if(this->Target->Target->IsCFBundleOnApple()) + else if(this->Target->IsCFBundleOnApple()) { // Install the whole app bundle directory. type = cmInstallType_DIRECTORY; @@ -351,7 +350,7 @@ cmInstallTargetGenerator::GetDestination(std::string const& config) const { cmGeneratorExpression ge; return ge.Parse(this->Destination) - ->Evaluate(this->Target->Target->GetMakefile(), config); + ->Evaluate(this->Target->GetLocalGenerator(), config); } //---------------------------------------------------------------------------- @@ -360,28 +359,25 @@ cmInstallTargetGenerator::GetInstallFilename(const std::string& config) const { NameType nameType = this->ImportLibrary? NameImplib : NameNormal; return - cmInstallTargetGenerator::GetInstallFilename(this->Target->Target, config, + cmInstallTargetGenerator::GetInstallFilename(this->Target, config, nameType); } //---------------------------------------------------------------------------- std::string -cmInstallTargetGenerator::GetInstallFilename(cmTarget const* target, +cmInstallTargetGenerator::GetInstallFilename(cmGeneratorTarget const* target, const std::string& config, NameType nameType) { std::string fname; // Compute the name of the library. - cmGeneratorTarget *gtgt = target->GetMakefile() - ->GetGlobalGenerator() - ->GetGeneratorTarget(target); - if(target->GetType() == cmTarget::EXECUTABLE) + if(target->GetType() == cmState::EXECUTABLE) { std::string targetName; std::string targetNameReal; std::string targetNameImport; std::string targetNamePDB; - gtgt->GetExecutableNames(targetName, targetNameReal, + target->GetExecutableNames(targetName, targetNameReal, targetNameImport, targetNamePDB, config); if(nameType == NameImplib) @@ -411,7 +407,7 @@ cmInstallTargetGenerator::GetInstallFilename(cmTarget const* target, std::string targetNameReal; std::string targetNameImport; std::string targetNamePDB; - gtgt->GetLibraryNames(targetName, targetNameSO, targetNameReal, + target->GetLibraryNames(targetName, targetNameSO, targetNameReal, targetNameImport, targetNamePDB, config); if(nameType == NameImplib) { @@ -444,8 +440,7 @@ cmInstallTargetGenerator::GetInstallFilename(cmTarget const* target, void cmInstallTargetGenerator::Compute(cmLocalGenerator* lg) { - this->Target = lg->GetGlobalGenerator()->GetGeneratorTarget( - lg->GetMakefile()->FindTarget(this->TargetName)); + this->Target = lg->FindGeneratorTarget(this->TargetName); } //---------------------------------------------------------------------------- @@ -542,9 +537,9 @@ cmInstallTargetGenerator std::string const& toDestDirPath) { if(this->ImportLibrary || - !(this->Target->GetType() == cmTarget::SHARED_LIBRARY || - this->Target->GetType() == cmTarget::MODULE_LIBRARY || - this->Target->GetType() == cmTarget::EXECUTABLE)) + !(this->Target->GetType() == cmState::SHARED_LIBRARY || + this->Target->GetType() == cmState::MODULE_LIBRARY || + this->Target->GetType() == cmState::EXECUTABLE)) { return; } @@ -563,12 +558,12 @@ cmInstallTargetGenerator std::map<std::string, std::string> install_name_remap; if(cmComputeLinkInformation* cli = this->Target->GetLinkInformation(config)) { - std::set<cmTarget const*> const& sharedLibs + std::set<cmGeneratorTarget const*> const& sharedLibs = cli->GetSharedLibrariesLinked(); - for(std::set<cmTarget const*>::const_iterator j = sharedLibs.begin(); - j != sharedLibs.end(); ++j) + for(std::set<cmGeneratorTarget const*>::const_iterator j + = sharedLibs.begin(); j != sharedLibs.end(); ++j) { - cmTarget const* tgt = *j; + cmGeneratorTarget const* tgt = *j; // The install_name of an imported target does not change. if(tgt->IsImported()) @@ -576,14 +571,11 @@ cmInstallTargetGenerator continue; } - cmGeneratorTarget *gtgt = tgt->GetMakefile() - ->GetGlobalGenerator() - ->GetGeneratorTarget(tgt); // If the build tree and install tree use different path // components of the install_name field then we need to create a // mapping to be applied after installation. - std::string for_build = gtgt->GetInstallNameDirForBuildTree(config); - std::string for_install = gtgt->GetInstallNameDirForInstallTree(); + std::string for_build = tgt->GetInstallNameDirForBuildTree(config); + std::string for_install = tgt->GetInstallNameDirForInstallTree(); if(for_build != for_install) { // The directory portions differ. Append the filename to @@ -605,14 +597,14 @@ cmInstallTargetGenerator // Edit the install_name of the target itself if necessary. std::string new_id; - if(this->Target->GetType() == cmTarget::SHARED_LIBRARY) + if(this->Target->GetType() == cmState::SHARED_LIBRARY) { std::string for_build = this->Target->GetInstallNameDirForBuildTree(config); std::string for_install = this->Target->GetInstallNameDirForInstallTree(); - if(this->Target->Target->IsFrameworkOnApple() && for_install.empty()) + if(this->Target->IsFrameworkOnApple() && for_install.empty()) { // Frameworks seem to have an id corresponding to their own full // path. @@ -626,7 +618,7 @@ cmInstallTargetGenerator { // Prepare to refer to the install-tree install_name. new_id = for_install; - new_id += this->GetInstallFilename(this->Target->Target, config, NameSO); + new_id += this->GetInstallFilename(this->Target, config, NameSO); } } @@ -816,14 +808,14 @@ cmInstallTargetGenerator::AddStripRule(std::ostream& os, // don't strip static and import libraries, because it removes the only // symbol table they have so you can't link to them anymore - if(this->Target->GetType()==cmTarget::STATIC_LIBRARY || this->ImportLibrary) + if(this->Target->GetType()==cmState::STATIC_LIBRARY || this->ImportLibrary) { return; } // Don't handle OSX Bundles. if(this->Target->Target->GetMakefile()->IsOn("APPLE") && - this->Target->Target->GetPropertyAsBool("MACOSX_BUNDLE")) + this->Target->GetPropertyAsBool("MACOSX_BUNDLE")) { return; } @@ -847,7 +839,7 @@ cmInstallTargetGenerator::AddRanlibRule(std::ostream& os, const std::string& toDestDirPath) { // Static libraries need ranlib on this platform. - if(this->Target->GetType() != cmTarget::STATIC_LIBRARY) + if(this->Target->GetType() != cmState::STATIC_LIBRARY) { return; } diff --git a/Source/cmInstallTargetGenerator.h b/Source/cmInstallTargetGenerator.h index a8f4a75..ec89c05 100644 --- a/Source/cmInstallTargetGenerator.h +++ b/Source/cmInstallTargetGenerator.h @@ -14,7 +14,6 @@ #include "cmInstallGenerator.h" -class cmTarget; class cmGeneratorTarget; /** \class cmInstallTargetGenerator @@ -54,7 +53,7 @@ public: NameReal }; - static std::string GetInstallFilename(cmTarget const* target, + static std::string GetInstallFilename(const cmGeneratorTarget* target, const std::string& config, NameType nameType = NameNormal); diff --git a/Source/cmLinkItem.h b/Source/cmLinkItem.h index 10dd465..b603bcc 100644 --- a/Source/cmLinkItem.h +++ b/Source/cmLinkItem.h @@ -14,8 +14,9 @@ #define cmLinkItem_h #include "cmListFileCache.h" +#include "cmSystemTools.h" -class cmTarget; +class cmGeneratorTarget; // Basic information about each link item. class cmLinkItem: public std::string @@ -24,9 +25,9 @@ class cmLinkItem: public std::string public: cmLinkItem(): std_string(), Target(0) {} cmLinkItem(const std_string& n, - cmTarget const* t): std_string(n), Target(t) {} + cmGeneratorTarget const* t): std_string(n), Target(t) {} cmLinkItem(cmLinkItem const& r): std_string(r), Target(r.Target) {} - cmTarget const* Target; + cmGeneratorTarget const* Target; }; class cmLinkImplItem: public cmLinkItem @@ -34,7 +35,7 @@ class cmLinkImplItem: public cmLinkItem public: cmLinkImplItem(): cmLinkItem(), Backtrace(), FromGenex(false) {} cmLinkImplItem(std::string const& n, - cmTarget const* t, + cmGeneratorTarget const* t, cmListFileBacktrace const& bt, bool fromGenex): cmLinkItem(n, t), Backtrace(bt), FromGenex(fromGenex) {} @@ -97,7 +98,7 @@ struct cmOptionalLinkInterface: public cmLinkInterface }; struct cmHeadToLinkInterfaceMap: - public std::map<cmTarget const*, cmOptionalLinkInterface> + public std::map<cmGeneratorTarget const*, cmOptionalLinkInterface> { }; @@ -118,4 +119,27 @@ struct cmOptionalLinkImplementation: public cmLinkImplementation bool HadHeadSensitiveCondition; }; +/** Compute the link type to use for the given configuration. */ +inline cmTargetLinkLibraryType +CMP0003_ComputeLinkType(const std::string& config, + std::vector<std::string> const& debugConfigs) +{ + // No configuration is always optimized. + if(config.empty()) + { + return OPTIMIZED_LibraryType; + } + + // Check if any entry in the list matches this configuration. + std::string configUpper = cmSystemTools::UpperCase(config); + if (std::find(debugConfigs.begin(), debugConfigs.end(), configUpper) != + debugConfigs.end()) + { + return DEBUG_LibraryType; + } + // The current configuration is not a debug configuration. + return OPTIMIZED_LibraryType; +} + + #endif diff --git a/Source/cmLinkLibrariesCommand.cxx b/Source/cmLinkLibrariesCommand.cxx index 996b538..eb3bfce 100644 --- a/Source/cmLinkLibrariesCommand.cxx +++ b/Source/cmLinkLibrariesCommand.cxx @@ -34,7 +34,7 @@ bool cmLinkLibrariesCommand return false; } this->Makefile->AddLinkLibrary(*i, - cmTarget::DEBUG); + DEBUG_LibraryType); } else if (*i == "optimized") { @@ -46,7 +46,7 @@ bool cmLinkLibrariesCommand return false; } this->Makefile->AddLinkLibrary(*i, - cmTarget::OPTIMIZED); + OPTIMIZED_LibraryType); } else { diff --git a/Source/cmListFileCache.cxx b/Source/cmListFileCache.cxx index 1465f90..7ba61f3 100644 --- a/Source/cmListFileCache.cxx +++ b/Source/cmListFileCache.cxx @@ -12,7 +12,7 @@ #include "cmListFileCache.h" #include "cmListFileLexer.h" -#include "cmLocalGenerator.h" +#include "cmOutputConverter.h" #include "cmSystemTools.h" #include "cmMakefile.h" #include "cmVersion.h" diff --git a/Source/cmListFileCache.h b/Source/cmListFileCache.h index 17ee10f..03e0abe 100644 --- a/Source/cmListFileCache.h +++ b/Source/cmListFileCache.h @@ -109,13 +109,4 @@ struct cmListFile std::vector<cmListFileFunction> Functions; }; -struct cmValueWithOrigin { - cmValueWithOrigin(const std::string &value, - const cmListFileBacktrace &bt) - : Value(value), Backtrace(bt) - {} - std::string Value; - cmListFileBacktrace Backtrace; -}; - #endif diff --git a/Source/cmLocalGenerator.cxx b/Source/cmLocalGenerator.cxx index 233e7fe..6a57374 100644 --- a/Source/cmLocalGenerator.cxx +++ b/Source/cmLocalGenerator.cxx @@ -51,6 +51,8 @@ cmLocalGenerator::cmLocalGenerator(cmGlobalGenerator* gg, this->Makefile = makefile; + this->AliasTargets = makefile->GetAliasTargets(); + this->EmitUniversalBinaryFlags = true; this->BackwardsCompatibility = 0; this->BackwardsCompatibilityFinal = false; @@ -60,6 +62,8 @@ cmLocalGenerator::cmLocalGenerator(cmGlobalGenerator* gg, cmLocalGenerator::~cmLocalGenerator() { + cmDeleteAll(this->GeneratorTargets); + cmDeleteAll(this->OwnedImportedGeneratorTargets); } void cmLocalGenerator::IssueMessage(cmake::MessageType t, @@ -132,16 +136,15 @@ void cmLocalGenerator::TraceDependencies() this->GlobalGenerator->CreateEvaluationSourceFiles(*ci); } // Generate the rule files for each target. - cmGeneratorTargetsType targets = this->Makefile->GetGeneratorTargets(); - for(cmGeneratorTargetsType::iterator t = targets.begin(); + std::vector<cmGeneratorTarget*> targets = this->GetGeneratorTargets(); + for(std::vector<cmGeneratorTarget*>::iterator t = targets.begin(); t != targets.end(); ++t) { - if (t->second->Target->IsImported() - || t->second->Target->GetType() == cmTarget::INTERFACE_LIBRARY) + if ((*t)->GetType() == cmState::INTERFACE_LIBRARY) { continue; } - t->second->TraceDependencies(); + (*t)->TraceDependencies(); } } @@ -448,6 +451,63 @@ void cmLocalGenerator::GenerateInstallRules() } } + +void cmLocalGenerator::AddGeneratorTarget(cmGeneratorTarget* gt) +{ + this->GeneratorTargets.push_back(gt); +} + +void cmLocalGenerator::AddImportedGeneratorTarget(cmGeneratorTarget* gt) +{ + this->ImportedGeneratorTargets.push_back(gt); +} + +void cmLocalGenerator::AddOwnedImportedGeneratorTarget(cmGeneratorTarget* gt) +{ + this->OwnedImportedGeneratorTargets.push_back(gt); +} + +struct NamedGeneratorTargetFinder +{ + NamedGeneratorTargetFinder(std::string const& name) + : Name(name) + { + + } + + bool operator()(cmGeneratorTarget* tgt) + { + return tgt->GetName() == this->Name; + } +private: + std::string Name; +}; + +cmGeneratorTarget* cmLocalGenerator::FindGeneratorTarget( + const std::string& name) const +{ + std::map<std::string, std::string>::const_iterator i = + this->AliasTargets.find(name); + if (i != this->AliasTargets.end()) + { + std::vector<cmGeneratorTarget*>::const_iterator ai = + std::find_if(this->GeneratorTargets.begin(), + this->GeneratorTargets.end(), + NamedGeneratorTargetFinder(i->second)); + return *ai; + } + std::vector<cmGeneratorTarget*>::const_iterator ti = + std::find_if(this->GeneratorTargets.begin(), + this->GeneratorTargets.end(), + NamedGeneratorTargetFinder(name)); + if ( ti != this->GeneratorTargets.end() ) + { + return *ti; + } + + return 0; +} + //---------------------------------------------------------------------------- void cmLocalGenerator::ComputeTargetManifest() { @@ -460,16 +520,12 @@ void cmLocalGenerator::ComputeTargetManifest() } // Add our targets to the manifest for each configuration. - cmGeneratorTargetsType targets = this->Makefile->GetGeneratorTargets(); - for(cmGeneratorTargetsType::iterator t = targets.begin(); + std::vector<cmGeneratorTarget*> targets = this->GetGeneratorTargets(); + for(std::vector<cmGeneratorTarget*>::iterator t = targets.begin(); t != targets.end(); ++t) { - cmGeneratorTarget& target = *t->second; - if (target.Target->GetType() == cmTarget::INTERFACE_LIBRARY) - { - continue; - } - if (target.Target->IsImported()) + cmGeneratorTarget* target = *t; + if (target->GetType() == cmState::INTERFACE_LIBRARY) { continue; } @@ -477,11 +533,16 @@ void cmLocalGenerator::ComputeTargetManifest() ci != configNames.end(); ++ci) { const char* config = ci->c_str(); - target.ComputeTargetManifest(config); + target->ComputeTargetManifest(config); } } } +bool cmLocalGenerator::IsRootMakefile() const +{ + return !this->StateSnapshot.GetBuildsystemDirectoryParent().IsValid(); +} + cmState* cmLocalGenerator::GetState() const { return this->GlobalGenerator->GetCMakeInstance()->GetState(); @@ -753,7 +814,7 @@ cmLocalGenerator::ExpandRuleVariable(std::string const& variable, } if(variable == "TARGET_TYPE") { - return cmTarget::GetTargetTypeName(replaceValues.CMTarget->GetType()); + return cmState::GetTargetTypeName(replaceValues.CMTarget->GetType()); } } if(replaceValues.Output) @@ -913,7 +974,7 @@ cmLocalGenerator::ExpandRuleVariables(std::string& s, } //---------------------------------------------------------------------------- -const char* cmLocalGenerator::GetRuleLauncher(cmTarget* target, +const char* cmLocalGenerator::GetRuleLauncher(cmGeneratorTarget* target, const std::string& prop) { if(target) @@ -927,7 +988,8 @@ const char* cmLocalGenerator::GetRuleLauncher(cmTarget* target, } //---------------------------------------------------------------------------- -void cmLocalGenerator::InsertRuleLauncher(std::string& s, cmTarget* target, +void cmLocalGenerator::InsertRuleLauncher(std::string& s, + cmGeneratorTarget* target, const std::string& prop) { if(const char* val = this->GetRuleLauncher(target, prop)) @@ -1080,27 +1142,23 @@ std::string cmLocalGenerator::GetIncludeFlags( //---------------------------------------------------------------------------- void cmLocalGenerator::AddCompileDefinitions(std::set<std::string>& defines, - cmTarget const* target, + cmGeneratorTarget const* target, const std::string& config, const std::string& lang) { std::vector<std::string> targetDefines; - cmGeneratorTarget* gtgt = this->GlobalGenerator->GetGeneratorTarget(target); - gtgt->GetCompileDefinitions(targetDefines, config, lang); + target->GetCompileDefinitions(targetDefines, config, lang); this->AppendDefines(defines, targetDefines); } //---------------------------------------------------------------------------- void cmLocalGenerator::AddCompileOptions( - std::string& flags, cmTarget* target, + std::string& flags, cmGeneratorTarget* target, const std::string& lang, const std::string& config ) { std::string langFlagRegexVar = std::string("CMAKE_")+lang+"_FLAG_REGEX"; - cmGeneratorTarget* gtgt = - this->GlobalGenerator->GetGeneratorTarget(target); - if(const char* langFlagRegexStr = this->Makefile->GetDefinition(langFlagRegexVar)) { @@ -1111,7 +1169,7 @@ void cmLocalGenerator::AddCompileOptions( { cmSystemTools::ParseWindowsCommandLine(targetFlags, opts); } - gtgt->GetCompileOptions(opts, config, lang); + target->GetCompileOptions(opts, config, lang); for(std::vector<std::string>::const_iterator i = opts.begin(); i != opts.end(); ++i) { @@ -1132,7 +1190,7 @@ void cmLocalGenerator::AddCompileOptions( this->AppendFlags(flags, targetFlags); } std::vector<std::string> opts; - gtgt->GetCompileOptions(opts, config, lang); + target->GetCompileOptions(opts, config, lang); for(std::vector<std::string>::const_iterator i = opts.begin(); i != opts.end(); ++i) { @@ -1141,11 +1199,11 @@ void cmLocalGenerator::AddCompileOptions( } } std::vector<std::string> features; - gtgt->GetCompileFeatures(features, config); + target->GetCompileFeatures(features, config); for(std::vector<std::string>::const_iterator it = features.begin(); it != features.end(); ++it) { - if (!this->Makefile->AddRequiredTargetFeature(target, *it)) + if (!this->Makefile->AddRequiredTargetFeature(target->Target, *it)) { return; } @@ -1180,7 +1238,7 @@ void cmLocalGenerator::AddCompileOptions( //---------------------------------------------------------------------------- void cmLocalGenerator::GetIncludeDirectories(std::vector<std::string>& dirs, - cmGeneratorTarget* target, + cmGeneratorTarget const* target, const std::string& lang, const std::string& config, bool stripImplicitInclDirs @@ -1307,7 +1365,7 @@ void cmLocalGenerator::GetIncludeDirectories(std::vector<std::string>& dirs, void cmLocalGenerator::GetStaticLibraryFlags(std::string& flags, std::string const& config, - cmTarget* target) + cmGeneratorTarget* target) { this->AppendFlags(flags, this->Makefile->GetSafeDefinition("CMAKE_STATIC_LINKER_FLAGS")); @@ -1340,12 +1398,12 @@ void cmLocalGenerator::GetTargetFlags(std::string& linkLibs, switch(target->GetType()) { - case cmTarget::STATIC_LIBRARY: - this->GetStaticLibraryFlags(linkFlags, buildType, target->Target); + case cmState::STATIC_LIBRARY: + this->GetStaticLibraryFlags(linkFlags, buildType, target); break; - case cmTarget::MODULE_LIBRARY: + case cmState::MODULE_LIBRARY: libraryLinkVariable = "CMAKE_MODULE_LINKER_FLAGS"; - case cmTarget::SHARED_LIBRARY: + case cmState::SHARED_LIBRARY: { linkFlags = this->Makefile->GetSafeDefinition(libraryLinkVariable); linkFlags += " "; @@ -1397,7 +1455,7 @@ void cmLocalGenerator::GetTargetFlags(std::string& linkLibs, *target, false, false, useWatcomQuote); } break; - case cmTarget::EXECUTABLE: + case cmState::EXECUTABLE: { linkFlags += this->Makefile->GetSafeDefinition("CMAKE_EXE_LINKER_FLAGS"); @@ -1414,7 +1472,7 @@ void cmLocalGenerator::GetTargetFlags(std::string& linkLibs, { cmSystemTools::Error ("CMake can not determine linker language for target: ", - target->Target->GetName().c_str()); + target->GetName().c_str()); return; } this->AddLanguageFlags(flags, linkLanguage, buildType); @@ -1440,7 +1498,7 @@ void cmLocalGenerator::GetTargetFlags(std::string& linkLibs, this->Makefile->GetSafeDefinition("CMAKE_CREATE_CONSOLE_EXE"); linkFlags += " "; } - if (target->Target->IsExecutableWithExports()) + if (target->IsExecutableWithExports()) { std::string exportFlagVar = "CMAKE_EXE_EXPORTS_"; exportFlagVar += linkLanguage; @@ -1542,12 +1600,12 @@ void cmLocalGenerator::OutputLinkLibraries(std::string& linkLibraries, this->Makefile->GetSafeDefinition("CMAKE_LIBRARY_PATH_TERMINATOR"); // Flags to link an executable to shared libraries. - if (tgt.GetType() == cmTarget::EXECUTABLE && + if (tgt.GetType() == cmState::EXECUTABLE && this->StateSnapshot.GetState()-> GetGlobalPropertyAsBool("TARGET_SUPPORTS_SHARED_LIBS")) { bool add_shlib_flags = false; - switch(tgt.Target->GetPolicyStatusCMP0065()) + switch(tgt.GetPolicyStatusCMP0065()) { case cmPolicies::WARN: if(!tgt.GetPropertyAsBool("ENABLE_EXPORTS") && @@ -1624,7 +1682,7 @@ void cmLocalGenerator::OutputLinkLibraries(std::string& linkLibraries, ItemVector const& items = cli.GetItems(); for(ItemVector::const_iterator li = items.begin(); li != items.end(); ++li) { - if(li->Target && li->Target->GetType() == cmTarget::INTERFACE_LIBRARY) + if(li->Target && li->Target->GetType() == cmState::INTERFACE_LIBRARY) { continue; } @@ -1767,6 +1825,27 @@ void cmLocalGenerator::AddLanguageFlags(std::string& flags, } //---------------------------------------------------------------------------- +cmGeneratorTarget* +cmLocalGenerator::FindGeneratorTargetToUse(const std::string& name) const +{ + std::vector<cmGeneratorTarget*>::const_iterator + imported = std::find_if(this->ImportedGeneratorTargets.begin(), + this->ImportedGeneratorTargets.end(), + NamedGeneratorTargetFinder(name)); + if(imported != this->ImportedGeneratorTargets.end()) + { + return *imported; + } + + if(cmGeneratorTarget* t = this->FindGeneratorTarget(name)) + { + return t; + } + + return this->GetGlobalGenerator()->FindGeneratorTarget(name); +} + +//---------------------------------------------------------------------------- bool cmLocalGenerator::GetRealDependency(const std::string& inName, const std::string& config, std::string& dep) @@ -1792,15 +1871,15 @@ bool cmLocalGenerator::GetRealDependency(const std::string& inName, // Look for a CMake target with the given name. if(cmGeneratorTarget* target = - this->Makefile->FindGeneratorTargetToUse(name)) + this->FindGeneratorTargetToUse(name)) { // make sure it is not just a coincidence that the target name // found is part of the inName if(cmSystemTools::FileIsFullPath(inName.c_str())) { std::string tLocation; - if(target->GetType() >= cmTarget::EXECUTABLE && - target->GetType() <= cmTarget::MODULE_LIBRARY) + if(target->GetType() >= cmState::EXECUTABLE && + target->GetType() <= cmState::MODULE_LIBRARY) { tLocation = target->GetLocation(config); tLocation = cmSystemTools::GetFilenamePath(tLocation); @@ -1820,23 +1899,23 @@ bool cmLocalGenerator::GetRealDependency(const std::string& inName, } switch (target->GetType()) { - case cmTarget::EXECUTABLE: - case cmTarget::STATIC_LIBRARY: - case cmTarget::SHARED_LIBRARY: - case cmTarget::MODULE_LIBRARY: - case cmTarget::UNKNOWN_LIBRARY: + case cmState::EXECUTABLE: + case cmState::STATIC_LIBRARY: + case cmState::SHARED_LIBRARY: + case cmState::MODULE_LIBRARY: + case cmState::UNKNOWN_LIBRARY: dep = target->GetLocation(config); return true; - case cmTarget::OBJECT_LIBRARY: + case cmState::OBJECT_LIBRARY: // An object library has no single file on which to depend. // This was listed to get the target-level dependency. return false; - case cmTarget::INTERFACE_LIBRARY: + case cmState::INTERFACE_LIBRARY: // An interface library has no file on which to depend. // This was listed to get the target-level dependency. return false; - case cmTarget::UTILITY: - case cmTarget::GLOBAL_TARGET: + case cmState::UTILITY: + case cmState::GLOBAL_TARGET: // A utility target has no file on which to depend. This was listed // only to get the target-level dependency. return false; @@ -1886,7 +1965,8 @@ void cmLocalGenerator::AddSharedFlags(std::string& flags, //---------------------------------------------------------------------------- void cmLocalGenerator:: -AddCompilerRequirementFlag(std::string &flags, cmTarget const* target, +AddCompilerRequirementFlag(std::string &flags, + cmGeneratorTarget const* target, const std::string& lang) { if (lang.empty()) @@ -1924,7 +2004,8 @@ AddCompilerRequirementFlag(std::string &flags, cmTarget const* target, "CMAKE_" + lang + standardProp + "_" + type + "_COMPILE_OPTION"; - const char *opt = target->GetMakefile()->GetDefinition(option_flag); + const char *opt = target->Target->GetMakefile() + ->GetDefinition(option_flag); if (!opt) { std::ostringstream e; @@ -1989,7 +2070,7 @@ AddCompilerRequirementFlag(std::string &flags, cmTarget const* target, + "_" + type + "_COMPILE_OPTION"; const char *opt = - target->GetMakefile()->GetRequiredDefinition(option_flag); + target->Target->GetMakefile()->GetRequiredDefinition(option_flag); this->AppendFlagEscape(flags, opt); return; } @@ -2000,7 +2081,8 @@ AddCompilerRequirementFlag(std::string &flags, cmTarget const* target, "CMAKE_" + lang + *stdIt + "_" + type + "_COMPILE_OPTION"; - if (const char *opt = target->GetMakefile()->GetDefinition(option_flag)) + if (const char *opt = target->Target + ->GetMakefile()->GetDefinition(option_flag)) { this->AppendFlagEscape(flags, opt); return; @@ -2009,7 +2091,7 @@ AddCompilerRequirementFlag(std::string &flags, cmTarget const* target, } static void AddVisibilityCompileOption(std::string &flags, - cmTarget const* target, + cmGeneratorTarget const* target, cmLocalGenerator *lg, const std::string& lang, std::string* warnCMP0063) @@ -2049,7 +2131,7 @@ static void AddVisibilityCompileOption(std::string &flags, } static void AddInlineVisibilityCompileOption(std::string &flags, - cmTarget const* target, + cmGeneratorTarget const* target, cmLocalGenerator *lg, std::string* warnCMP0063) { @@ -2076,7 +2158,7 @@ static void AddInlineVisibilityCompileOption(std::string &flags, //---------------------------------------------------------------------------- void cmLocalGenerator -::AddVisibilityPresetFlags(std::string &flags, cmTarget const* target, +::AddVisibilityPresetFlags(std::string &flags, cmGeneratorTarget const* target, const std::string& lang) { if (lang.empty()) @@ -2086,8 +2168,8 @@ void cmLocalGenerator std::string warnCMP0063; std::string *pWarnCMP0063 = 0; - if (target->GetType() != cmTarget::SHARED_LIBRARY && - target->GetType() != cmTarget::MODULE_LIBRARY && + if (target->GetType() != cmState::SHARED_LIBRARY && + target->GetType() != cmState::MODULE_LIBRARY && !target->IsExecutableWithExports()) { switch (target->GetPolicyStatusCMP0063()) @@ -2116,25 +2198,26 @@ void cmLocalGenerator w << cmPolicies::GetPolicyWarning(cmPolicies::CMP0063) << "\n" "Target \"" << target->GetName() << "\" of " - "type \"" << cmTarget::GetTargetTypeName(target->GetType()) << "\" " + "type \"" << cmState::GetTargetTypeName(target->GetType()) << "\" " "has the following visibility properties set for " << lang << ":\n" << warnCMP0063 << "For compatibility CMake is not honoring them for this target."; - target->GetMakefile()->GetCMakeInstance() - ->IssueMessage(cmake::AUTHOR_WARNING, w.str(), target->GetBacktrace()); + target->GetLocalGenerator()->GetCMakeInstance() + ->IssueMessage(cmake::AUTHOR_WARNING, w.str(), + target->GetBacktrace()); } } //---------------------------------------------------------------------------- void cmLocalGenerator::AddCMP0018Flags(std::string &flags, - cmTarget const* target, + cmGeneratorTarget const* target, std::string const& lang, const std::string& config) { int targetType = target->GetType(); - bool shared = ((targetType == cmTarget::SHARED_LIBRARY) || - (targetType == cmTarget::MODULE_LIBRARY)); + bool shared = ((targetType == cmState::SHARED_LIBRARY) || + (targetType == cmState::MODULE_LIBRARY)); if (this->GetShouldUseOldFlags(shared, lang)) { @@ -2142,7 +2225,7 @@ void cmLocalGenerator::AddCMP0018Flags(std::string &flags, } else { - if (target->GetType() == cmTarget::OBJECT_LIBRARY) + if (target->GetType() == cmState::OBJECT_LIBRARY) { if (target->GetPropertyAsBool("POSITION_INDEPENDENT_CODE")) { @@ -2151,9 +2234,7 @@ void cmLocalGenerator::AddCMP0018Flags(std::string &flags, return; } - cmGeneratorTarget* gtgt = - this->GlobalGenerator->GetGeneratorTarget(target); - if (gtgt->GetLinkInterfaceDependentBoolProperty( + if (target->GetLinkInterfaceDependentBoolProperty( "POSITION_INDEPENDENT_CODE", config)) { @@ -2182,7 +2263,7 @@ bool cmLocalGenerator::GetShouldUseOldFlags(bool shared, if (flags && flags != originalFlags) { - switch (this->Makefile->GetPolicyStatus(cmPolicies::CMP0018)) + switch (this->GetPolicyStatus(cmPolicies::CMP0018)) { case cmPolicies::WARN: { @@ -2216,7 +2297,7 @@ void cmLocalGenerator::AddPositionIndependentFlags(std::string& flags, { const char* picFlags = 0; - if(targetType == cmTarget::EXECUTABLE) + if(targetType == cmState::EXECUTABLE) { std::string flagsVar = "CMAKE_"; flagsVar += lang; @@ -2431,6 +2512,11 @@ const char* cmLocalGenerator::GetFeature(const std::string& feature, return 0; } +std::string cmLocalGenerator::GetProjectName() const +{ + return this->StateSnapshot.GetProjectName(); +} + //---------------------------------------------------------------------------- std::string cmLocalGenerator::ConstructComment(cmCustomCommandGenerator const& ccg, @@ -2486,28 +2572,29 @@ cmLocalGenerator { // Convert the old-style install specification from each target to // an install generator and run it. - cmTargets& tgts = this->Makefile->GetTargets(); - for(cmTargets::iterator l = tgts.begin(); l != tgts.end(); ++l) + std::vector<cmGeneratorTarget*> tgts = this->GetGeneratorTargets(); + for(std::vector<cmGeneratorTarget*>::iterator l = tgts.begin(); + l != tgts.end(); ++l) { - if (l->second.GetType() == cmTarget::INTERFACE_LIBRARY) + if ((*l)->GetType() == cmState::INTERFACE_LIBRARY) { continue; } // Include the user-specified pre-install script for this target. - if(const char* preinstall = l->second.GetProperty("PRE_INSTALL_SCRIPT")) + if(const char* preinstall = (*l)->GetProperty("PRE_INSTALL_SCRIPT")) { cmInstallScriptGenerator g(preinstall, false, 0); g.Generate(os, config, configurationTypes); } // Install this target if a destination is given. - if(l->second.GetInstallPath() != "") + if((*l)->Target->GetInstallPath() != "") { // Compute the full install destination. Note that converting // to unix slashes also removes any trailing slash. // We also skip over the leading slash given by the user. - std::string destination = l->second.GetInstallPath().substr(1); + std::string destination = (*l)->Target->GetInstallPath().substr(1); cmSystemTools::ConvertToUnixSlashes(destination); if(destination.empty()) { @@ -2515,37 +2602,37 @@ cmLocalGenerator } // Generate the proper install generator for this target type. - switch(l->second.GetType()) + switch((*l)->GetType()) { - case cmTarget::EXECUTABLE: - case cmTarget::STATIC_LIBRARY: - case cmTarget::MODULE_LIBRARY: + case cmState::EXECUTABLE: + case cmState::STATIC_LIBRARY: + case cmState::MODULE_LIBRARY: { // Use a target install generator. cmInstallTargetGeneratorLocal - g(this, l->first, destination.c_str(), false); + g(this, (*l)->GetName(), destination.c_str(), false); g.Generate(os, config, configurationTypes); } break; - case cmTarget::SHARED_LIBRARY: + case cmState::SHARED_LIBRARY: { #if defined(_WIN32) || defined(__CYGWIN__) // Special code to handle DLL. Install the import library // to the normal destination and the DLL to the runtime // destination. cmInstallTargetGeneratorLocal - g1(this, l->first, destination.c_str(), true); + g1(this, (*l)->GetName(), destination.c_str(), true); g1.Generate(os, config, configurationTypes); // We also skip over the leading slash given by the user. - destination = l->second.GetRuntimeInstallPath().substr(1); + destination = (*l)->Target->GetRuntimeInstallPath().substr(1); cmSystemTools::ConvertToUnixSlashes(destination); cmInstallTargetGeneratorLocal - g2(this, l->first, destination.c_str(), false); + g2(this, (*l)->GetName(), destination.c_str(), false); g2.Generate(os, config, configurationTypes); #else // Use a target install generator. cmInstallTargetGeneratorLocal - g(this, l->first, destination.c_str(), false); + g(this, (*l)->GetName(), destination.c_str(), false); g.Generate(os, config, configurationTypes); #endif } @@ -2556,7 +2643,7 @@ cmLocalGenerator } // Include the user-specified post-install script for this target. - if(const char* postinstall = l->second.GetProperty("POST_INSTALL_SCRIPT")) + if(const char* postinstall = (*l)->GetProperty("POST_INSTALL_SCRIPT")) { cmInstallScriptGenerator g(postinstall, false, 0); g.Generate(os, config, configurationTypes); @@ -2858,9 +2945,34 @@ cmLocalGenerator return source.GetLanguage(); } +cmake* cmLocalGenerator::GetCMakeInstance() const +{ + return this->GlobalGenerator->GetCMakeInstance(); +} + +const char* cmLocalGenerator::GetSourceDirectory() const +{ + return this->GetCMakeInstance()->GetHomeDirectory(); +} + +const char* cmLocalGenerator::GetBinaryDirectory() const +{ + return this->GetCMakeInstance()->GetHomeOutputDirectory(); +} + +const char* cmLocalGenerator::GetCurrentBinaryDirectory() const +{ + return this->StateSnapshot.GetDirectory().GetCurrentBinary(); +} + +const char* cmLocalGenerator::GetCurrentSourceDirectory() const +{ + return this->StateSnapshot.GetDirectory().GetCurrentSource(); +} + //---------------------------------------------------------------------------- std::string -cmLocalGenerator::GetTargetDirectory(cmTarget const&) const +cmLocalGenerator::GetTargetDirectory(const cmGeneratorTarget*) const { cmSystemTools::Error("GetTargetDirectory" " called on cmLocalGenerator"); @@ -2899,7 +3011,7 @@ bool cmLocalGenerator::NeedBackwardsCompatibility_2_4() { // Check the policy to decide whether to pay attention to this // variable. - switch(this->Makefile->GetPolicyStatus(cmPolicies::CMP0001)) + switch(this->GetPolicyStatus(cmPolicies::CMP0001)) { case cmPolicies::WARN: // WARN is just OLD without warning because user code does not @@ -2926,6 +3038,12 @@ bool cmLocalGenerator::NeedBackwardsCompatibility_2_4() actual_compat <= CMake_VERSION_ENCODE(2, 4, 255)); } +cmPolicies::PolicyStatus +cmLocalGenerator::GetPolicyStatus(cmPolicies::PolicyID id) const +{ + return this->Makefile->GetPolicyStatus(id); +} + //---------------------------------------------------------------------------- bool cmLocalGenerator::CheckDefinition(std::string const& define) const { @@ -2964,7 +3082,7 @@ bool cmLocalGenerator::CheckDefinition(std::string const& define) const } //---------------------------------------------------------------------------- -static void cmLGInfoProp(cmMakefile* mf, cmTarget* target, +static void cmLGInfoProp(cmMakefile* mf, cmGeneratorTarget* target, const std::string& prop) { if(const char* val = target->GetProperty(prop)) @@ -2974,7 +3092,7 @@ static void cmLGInfoProp(cmMakefile* mf, cmTarget* target, } //---------------------------------------------------------------------------- -void cmLocalGenerator::GenerateAppleInfoPList(cmTarget* target, +void cmLocalGenerator::GenerateAppleInfoPList(cmGeneratorTarget* target, const std::string& targetName, const char* fname) { @@ -3017,7 +3135,7 @@ void cmLocalGenerator::GenerateAppleInfoPList(cmTarget* target, } //---------------------------------------------------------------------------- -void cmLocalGenerator::GenerateFrameworkInfoPList(cmTarget* target, +void cmLocalGenerator::GenerateFrameworkInfoPList(cmGeneratorTarget* target, const std::string& targetName, const char* fname) { diff --git a/Source/cmLocalGenerator.h b/Source/cmLocalGenerator.h index 6ea414a..e2f5519 100644 --- a/Source/cmLocalGenerator.h +++ b/Source/cmLocalGenerator.h @@ -20,7 +20,6 @@ class cmMakefile; class cmGlobalGenerator; class cmGeneratorTarget; -class cmTarget; class cmTargetManifest; class cmSourceFile; class cmCustomCommand; @@ -68,6 +67,8 @@ public: */ void ComputeTargetManifest(); + bool IsRootMakefile() const; + ///! Get the makefile for this generator cmMakefile *GetMakefile() { return this->Makefile; } @@ -91,13 +92,15 @@ public: void AddLanguageFlags(std::string& flags, const std::string& lang, const std::string& config); - void AddCMP0018Flags(std::string &flags, cmTarget const* target, + void AddCMP0018Flags(std::string &flags, cmGeneratorTarget const* target, std::string const& lang, const std::string& config); - void AddVisibilityPresetFlags(std::string &flags, cmTarget const* target, + void AddVisibilityPresetFlags(std::string &flags, + cmGeneratorTarget const* target, const std::string& lang); void AddConfigVariableFlags(std::string& flags, const std::string& var, const std::string& config); - void AddCompilerRequirementFlag(std::string &flags, cmTarget const* target, + void AddCompilerRequirementFlag(std::string &flags, + cmGeneratorTarget const* target, const std::string& lang); ///! Append flags to a string. virtual void AppendFlags(std::string& flags, const std::string& newFlags); @@ -112,6 +115,23 @@ public: bool forResponseFile = false, const std::string& config = ""); + const std::vector<cmGeneratorTarget*> &GetGeneratorTargets() const + { + return this->GeneratorTargets; + } + + const std::vector<cmGeneratorTarget*> &GetImportedGeneratorTargets() const + { + return this->ImportedGeneratorTargets; + } + + void AddGeneratorTarget(cmGeneratorTarget* gt); + void AddImportedGeneratorTarget(cmGeneratorTarget* gt); + void AddOwnedImportedGeneratorTarget(cmGeneratorTarget* gt); + + cmGeneratorTarget* FindGeneratorTarget(const std::string& name) const; + cmGeneratorTarget* FindGeneratorTargetToUse(const std::string& name) const; + /** * Encode a list of preprocessor definitions for the compiler * command line. @@ -171,23 +191,25 @@ public: /** Get the include flags for the current makefile and language. */ void GetIncludeDirectories(std::vector<std::string>& dirs, - cmGeneratorTarget* target, + cmGeneratorTarget const* target, const std::string& lang = "C", const std::string& config = "", bool stripImplicitInclDirs = true) const; - void AddCompileOptions(std::string& flags, cmTarget* target, + void AddCompileOptions(std::string& flags, cmGeneratorTarget* target, const std::string& lang, const std::string& config); void AddCompileDefinitions(std::set<std::string>& defines, - cmTarget const* target, + cmGeneratorTarget const* target, const std::string& config, const std::string& lang); + std::string GetProjectName() const; + /** Compute the language used to compile the given source file. */ std::string GetSourceFileLanguage(const cmSourceFile& source); // Fill the vector with the target names for the object files, // preprocessed files and assembly files. - virtual void GetIndividualFileTargets(std::vector<std::string>&) {} + void GetIndividualFileTargets(std::vector<std::string>&) {} // Create a struct to hold the varibles passed into // ExpandRuleVariables @@ -197,7 +219,7 @@ public: { memset(this, 0, sizeof(*this)); } - cmTarget* CMTarget; + cmGeneratorTarget* CMTarget; const char* TargetPDB; const char* TargetCompilePDB; const char* TargetVersionMajor; @@ -232,7 +254,8 @@ public: * Get the relative path from the generator output directory to a * per-target support directory. */ - virtual std::string GetTargetDirectory(cmTarget const& target) const; + virtual std::string + GetTargetDirectory(cmGeneratorTarget const* target) const; /** * Get the level of backwards compatibility requested by the project @@ -251,16 +274,27 @@ public: */ bool NeedBackwardsCompatibility_2_4(); + cmPolicies::PolicyStatus GetPolicyStatus(cmPolicies::PolicyID id) const; + + cmake* GetCMakeInstance() const; + + const char* GetSourceDirectory() const; + const char* GetBinaryDirectory() const; + + const char* GetCurrentBinaryDirectory() const; + const char* GetCurrentSourceDirectory() const; + /** * Generate a Mac OS X application bundle Info.plist file. */ - void GenerateAppleInfoPList(cmTarget* target, const std::string& targetName, + void GenerateAppleInfoPList(cmGeneratorTarget* target, + const std::string& targetName, const char* fname); /** * Generate a Mac OS X framework Info.plist file. */ - void GenerateFrameworkInfoPList(cmTarget* target, + void GenerateFrameworkInfoPList(cmGeneratorTarget* target, const std::string& targetName, const char* fname); /** Construct a comment for a custom command. */ @@ -274,7 +308,7 @@ public: /** Fill out the static linker flags for the given target. */ void GetStaticLibraryFlags(std::string& flags, std::string const& config, - cmTarget* target); + cmGeneratorTarget* target); /** Fill out these strings for the given target. Libraries to link, * flags, and linkflags. */ @@ -317,8 +351,9 @@ protected: std::string ExpandRuleVariable(std::string const& variable, const RuleVariables& replaceValues); - const char* GetRuleLauncher(cmTarget* target, const std::string& prop); - void InsertRuleLauncher(std::string& s, cmTarget* target, + const char* GetRuleLauncher(cmGeneratorTarget* target, + const std::string& prop); + void InsertRuleLauncher(std::string& s, cmGeneratorTarget* target, const std::string& prop); // Handle old-style install rules stored in the targets. @@ -343,7 +378,11 @@ protected: std::string::size_type ObjectPathMax; std::set<std::string> ObjectMaxPathViolations; - std::set<cmTarget const*> WarnCMP0063; + std::set<cmGeneratorTarget const*> WarnCMP0063; + std::vector<cmGeneratorTarget*> GeneratorTargets; + std::vector<cmGeneratorTarget*> ImportedGeneratorTargets; + std::vector<cmGeneratorTarget*> OwnedImportedGeneratorTargets; + std::map<std::string, std::string> AliasTargets; bool EmitUniversalBinaryFlags; diff --git a/Source/cmLocalGhsMultiGenerator.cxx b/Source/cmLocalGhsMultiGenerator.cxx index bac989f..a77a75e 100644 --- a/Source/cmLocalGhsMultiGenerator.cxx +++ b/Source/cmLocalGhsMultiGenerator.cxx @@ -26,17 +26,16 @@ cmLocalGhsMultiGenerator::~cmLocalGhsMultiGenerator() {} void cmLocalGhsMultiGenerator::Generate() { - cmGeneratorTargetsType tgts = this->GetMakefile()->GetGeneratorTargets(); + std::vector<cmGeneratorTarget*> tgts = this->GetGeneratorTargets(); - for (cmGeneratorTargetsType::iterator l = tgts.begin(); l != tgts.end(); - ++l) + for (std::vector<cmGeneratorTarget*>::iterator l = tgts.begin(); + l != tgts.end(); ++l) { - if (l->second->Target->GetType() == cmTarget::INTERFACE_LIBRARY - || l->second->Target->IsImported()) + if ((*l)->GetType() == cmState::INTERFACE_LIBRARY) { continue; } - cmGhsMultiTargetGenerator tg(l->second); + cmGhsMultiTargetGenerator tg(*l); tg.Generate(); } } diff --git a/Source/cmLocalNinjaGenerator.cxx b/Source/cmLocalNinjaGenerator.cxx index c46adc1..b2927a9 100644 --- a/Source/cmLocalNinjaGenerator.cxx +++ b/Source/cmLocalNinjaGenerator.cxx @@ -42,7 +42,7 @@ void cmLocalNinjaGenerator::Generate() // Compute the path to use when referencing the current output // directory from the top output directory. this->HomeRelativeOutputPath = - this->Convert(this->Makefile->GetCurrentBinaryDirectory(), HOME_OUTPUT); + this->Convert(this->GetCurrentBinaryDirectory(), HOME_OUTPUT); if(this->HomeRelativeOutputPath == ".") { this->HomeRelativeOutputPath = ""; @@ -56,7 +56,7 @@ void cmLocalNinjaGenerator::Generate() #endif // We do that only once for the top CMakeLists.txt file. - if(this->Makefile->IsRootMakefile()) + if(this->IsRootMakefile()) { this->WriteBuildFileTop(); @@ -73,24 +73,23 @@ void cmLocalNinjaGenerator::Generate() } } - cmGeneratorTargetsType targets = this->GetMakefile()->GetGeneratorTargets(); - for(cmGeneratorTargetsType::iterator t = targets.begin(); + std::vector<cmGeneratorTarget*> targets = this->GetGeneratorTargets(); + for(std::vector<cmGeneratorTarget*>::iterator t = targets.begin(); t != targets.end(); ++t) { - if (t->second->Target->GetType() == cmTarget::INTERFACE_LIBRARY - || t->second->Target->IsImported()) + if ((*t)->GetType() == cmState::INTERFACE_LIBRARY) { continue; } - cmNinjaTargetGenerator* tg = cmNinjaTargetGenerator::New(t->second); + cmNinjaTargetGenerator* tg = cmNinjaTargetGenerator::New(*t); if(tg) { tg->Generate(); // Add the target to "all" if required. if (!this->GetGlobalNinjaGenerator()->IsExcluded( this->GetGlobalNinjaGenerator()->GetLocalGenerators()[0], - t->second)) - this->GetGlobalNinjaGenerator()->AddDependencyToAll(t->second->Target); + *t)) + this->GetGlobalNinjaGenerator()->AddDependencyToAll(*t); delete tg; } } @@ -100,10 +99,10 @@ void cmLocalNinjaGenerator::Generate() // TODO: Picked up from cmLocalUnixMakefileGenerator3. Refactor it. std::string cmLocalNinjaGenerator -::GetTargetDirectory(cmTarget const& target) const +::GetTargetDirectory(cmGeneratorTarget const* target) const { std::string dir = cmake::GetCMakeFilesDirectoryPostSlash(); - dir += target.GetName(); + dir += target->GetName(); #if defined(__VMS) dir += "_dir"; #else @@ -183,7 +182,7 @@ void cmLocalNinjaGenerator::WriteProjectHeader(std::ostream& os) { cmGlobalNinjaGenerator::WriteDivider(os); os - << "# Project: " << this->GetMakefile()->GetProjectName() << std::endl + << "# Project: " << this->GetProjectName() << std::endl << "# Configuration: " << this->ConfigName << std::endl ; cmGlobalNinjaGenerator::WriteDivider(os); @@ -278,7 +277,7 @@ void cmLocalNinjaGenerator::WriteProcessedMakefile(std::ostream& os) << "# Write statements declared in CMakeLists.txt:" << std::endl << "# " << this->Makefile->GetDefinition("CMAKE_CURRENT_LIST_FILE") << std::endl; - if(this->Makefile->IsRootMakefile()) + if(this->IsRootMakefile()) os << "# Which is the root file." << std::endl; cmGlobalNinjaGenerator::WriteDivider(os); os << std::endl; @@ -286,14 +285,14 @@ void cmLocalNinjaGenerator::WriteProcessedMakefile(std::ostream& os) void cmLocalNinjaGenerator -::AppendTargetOutputs(cmTarget* target, cmNinjaDeps& outputs) +::AppendTargetOutputs(cmGeneratorTarget* target, cmNinjaDeps& outputs) { this->GetGlobalNinjaGenerator()->AppendTargetOutputs(target, outputs); } void cmLocalNinjaGenerator -::AppendTargetDepends(cmTarget* target, cmNinjaDeps& outputs) +::AppendTargetDepends(cmGeneratorTarget* target, cmNinjaDeps& outputs) { this->GetGlobalNinjaGenerator()->AppendTargetDepends(target, outputs); } @@ -363,7 +362,7 @@ void cmLocalNinjaGenerator::AppendCustomCommandLines( if (ccg.GetNumberOfCommands() > 0) { std::string wd = ccg.GetWorkingDirectory(); if (wd.empty()) - wd = this->GetMakefile()->GetCurrentBinaryDirectory(); + wd = this->GetCurrentBinaryDirectory(); std::ostringstream cdCmd; #ifdef _WIN32 @@ -399,6 +398,16 @@ cmLocalNinjaGenerator::WriteCustomCommandBuildStatement( const std::vector<std::string> &byproducts = ccg.GetByproducts(); cmNinjaDeps ninjaOutputs(outputs.size()+byproducts.size()), ninjaDeps; + bool symbolic = false; + for (std::vector<std::string>::const_iterator o = outputs.begin(); + o != outputs.end(); ++o) + { + if (cmSourceFile* sf = this->Makefile->GetSource(*o)) + { + symbolic = sf->GetPropertyAsBool("SYMBOLIC"); + } + } + #if 0 #error TODO: Once CC in an ExternalProject target must provide the \ file of each imported target that has an add_dependencies pointing \ @@ -435,6 +444,7 @@ cmLocalNinjaGenerator::WriteCustomCommandBuildStatement( this->ConstructComment(ccg), "Custom command for " + ninjaOutputs[0], cc->GetUsesTerminal(), + /*restat*/!symbolic, ninjaOutputs, ninjaDeps, orderOnlyDeps); @@ -442,7 +452,7 @@ cmLocalNinjaGenerator::WriteCustomCommandBuildStatement( } void cmLocalNinjaGenerator::AddCustomCommandTarget(cmCustomCommand const* cc, - cmTarget* target) + cmGeneratorTarget* target) { this->CustomCommandTargets[cc].insert(target); } @@ -460,7 +470,7 @@ void cmLocalNinjaGenerator::WriteCustomCommandBuildStatements() // // FIXME: This won't work in certain obscure scenarios involving indirect // dependencies. - std::set<cmTarget*>::iterator j = i->second.begin(); + std::set<cmGeneratorTarget*>::iterator j = i->second.begin(); assert(j != i->second.end()); std::vector<std::string> ccTargetDeps; this->AppendTargetDepends(*j, ccTargetDeps); diff --git a/Source/cmLocalNinjaGenerator.h b/Source/cmLocalNinjaGenerator.h index 1645a8d..b6987ef 100644 --- a/Source/cmLocalNinjaGenerator.h +++ b/Source/cmLocalNinjaGenerator.h @@ -37,7 +37,8 @@ public: virtual void Generate(); - virtual std::string GetTargetDirectory(cmTarget const& target) const; + virtual + std::string GetTargetDirectory(cmGeneratorTarget const* target) const; const cmGlobalNinjaGenerator* GetGlobalNinjaGenerator() const; cmGlobalNinjaGenerator* GetGlobalNinjaGenerator(); @@ -57,10 +58,11 @@ public: std::string BuildCommandLine(const std::vector<std::string> &cmdLines); - void AppendTargetOutputs(cmTarget* target, cmNinjaDeps& outputs); - void AppendTargetDepends(cmTarget* target, cmNinjaDeps& outputs); + void AppendTargetOutputs(cmGeneratorTarget* target, cmNinjaDeps& outputs); + void AppendTargetDepends(cmGeneratorTarget* target, cmNinjaDeps& outputs); - void AddCustomCommandTarget(cmCustomCommand const* cc, cmTarget* target); + void AddCustomCommandTarget(cmCustomCommand const* cc, + cmGeneratorTarget* target); void AppendCustomCommandLines(cmCustomCommandGenerator const& ccg, std::vector<std::string> &cmdLines); void AppendCustomCommandDeps(cmCustomCommandGenerator const& ccg, @@ -101,7 +103,7 @@ private: std::string HomeRelativeOutputPath; - typedef std::map<cmCustomCommand const*, std::set<cmTarget*> > + typedef std::map<cmCustomCommand const*, std::set<cmGeneratorTarget*> > CustomCommandTargetMap; CustomCommandTargetMap CustomCommandTargets; }; diff --git a/Source/cmLocalUnixMakefileGenerator3.cxx b/Source/cmLocalUnixMakefileGenerator3.cxx index b131a63..62fea3d 100644 --- a/Source/cmLocalUnixMakefileGenerator3.cxx +++ b/Source/cmLocalUnixMakefileGenerator3.cxx @@ -113,19 +113,18 @@ void cmLocalUnixMakefileGenerator3::Generate() this->Makefile->IsOn("CMAKE_SKIP_ASSEMBLY_SOURCE_RULES"); // Generate the rule files for each target. - cmGeneratorTargetsType targets = this->Makefile->GetGeneratorTargets(); + std::vector<cmGeneratorTarget*> targets = this->GetGeneratorTargets(); cmGlobalUnixMakefileGenerator3* gg = static_cast<cmGlobalUnixMakefileGenerator3*>(this->GlobalGenerator); - for(cmGeneratorTargetsType::iterator t = targets.begin(); + for(std::vector<cmGeneratorTarget*>::iterator t = targets.begin(); t != targets.end(); ++t) { - if (t->second->Target->GetType() == cmTarget::INTERFACE_LIBRARY - || t->second->Target->IsImported()) + if ((*t)->GetType() == cmState::INTERFACE_LIBRARY) { continue; } cmsys::auto_ptr<cmMakefileTargetGenerator> tg( - cmMakefileTargetGenerator::New(t->second)); + cmMakefileTargetGenerator::New(*t)); if (tg.get()) { tg->WriteRuleFiles(); @@ -145,7 +144,7 @@ void cmLocalUnixMakefileGenerator3::ComputeHomeRelativeOutputPath() // Compute the path to use when referencing the current output // directory from the top output directory. this->HomeRelativeOutputPath = - this->Convert(this->Makefile->GetCurrentBinaryDirectory(), HOME_OUTPUT); + this->Convert(this->GetCurrentBinaryDirectory(), HOME_OUTPUT); if(this->HomeRelativeOutputPath == ".") { this->HomeRelativeOutputPath = ""; @@ -174,13 +173,12 @@ void cmLocalUnixMakefileGenerator3::ComputeObjectFilenames( void cmLocalUnixMakefileGenerator3:: GetLocalObjectFiles(std::map<std::string, LocalObjectInfo> &localObjectFiles) { - std::set<std::string> emitted; - cmGeneratorTargetsType targets = this->Makefile->GetGeneratorTargets(); - for(cmGeneratorTargetsType::iterator ti = targets.begin(); + std::vector<cmGeneratorTarget*> targets = this->GetGeneratorTargets(); + for(std::vector<cmGeneratorTarget*>::iterator ti = targets.begin(); ti != targets.end(); ++ti) { - cmGeneratorTarget* gt = ti->second; - if (gt->GetType() == cmTarget::INTERFACE_LIBRARY) + cmGeneratorTarget* gt = *ti; + if (gt->GetType() == cmState::INTERFACE_LIBRARY) { continue; } @@ -189,9 +187,9 @@ GetLocalObjectFiles(std::map<std::string, LocalObjectInfo> &localObjectFiles) ->GetSafeDefinition("CMAKE_BUILD_TYPE")); // Compute full path to object file directory for this target. std::string dir; - dir += gt->Makefile->GetCurrentBinaryDirectory(); + dir += gt->LocalGenerator->GetCurrentBinaryDirectory(); dir += "/"; - dir += this->GetTargetDirectory(*gt->Target); + dir += this->GetTargetDirectory(gt); dir += "/"; // Compute the name of each object file. for(std::vector<cmSourceFile const*>::iterator @@ -209,7 +207,7 @@ GetLocalObjectFiles(std::map<std::string, LocalObjectInfo> &localObjectFiles) } LocalObjectInfo& info = localObjectFiles[objectName]; info.HasSourceExtension = hasSourceExtension; - info.push_back(LocalObjectEntry(gt->Target, sf->GetLanguage())); + info.push_back(LocalObjectEntry(gt, sf->GetLanguage())); } } } @@ -255,7 +253,7 @@ void cmLocalUnixMakefileGenerator3::WriteLocalMakefile() return; } // always write the top makefile - if (!this->GetMakefile()->IsRootMakefile()) + if (!this->IsRootMakefile()) { ruleFileStream.SetCopyIfDifferent(true); } @@ -266,7 +264,7 @@ void cmLocalUnixMakefileGenerator3::WriteLocalMakefile() // only write local targets unless at the top Keep track of targets already // listed. std::set<std::string> emittedTargets; - if (!this->GetMakefile()->IsRootMakefile()) + if (!this->IsRootMakefile()) { // write our targets, and while doing it collect up the object // file rules @@ -389,7 +387,7 @@ cmLocalUnixMakefileGenerator3 t != info.end(); ++t) { std::string tgtMakefileName = - this->GetRelativeTargetDirectory(*(t->Target)); + this->GetRelativeTargetDirectory(t->Target); std::string targetName = tgtMakefileName; tgtMakefileName += "/build.make"; targetName += "/"; @@ -399,7 +397,7 @@ cmLocalUnixMakefileGenerator3 ); } this->CreateCDCommand(commands, - this->Makefile->GetHomeOutputDirectory(), + this->GetBinaryDirectory(), cmLocalGenerator::START_OUTPUT); // Write the rule to the makefile. @@ -418,27 +416,22 @@ void cmLocalUnixMakefileGenerator3 // for each target we just provide a rule to cd up to the top and do a make // on the target - cmGeneratorTargetsType targets = this->Makefile->GetGeneratorTargets(); + std::vector<cmGeneratorTarget*> targets = this->GetGeneratorTargets(); std::string localName; - for(cmGeneratorTargetsType::iterator t = targets.begin(); + for(std::vector<cmGeneratorTarget*>::iterator t = targets.begin(); t != targets.end(); ++t) { - if((t->second->GetType() == cmTarget::EXECUTABLE) || - (t->second->GetType() == cmTarget::STATIC_LIBRARY) || - (t->second->GetType() == cmTarget::SHARED_LIBRARY) || - (t->second->GetType() == cmTarget::MODULE_LIBRARY) || - (t->second->GetType() == cmTarget::OBJECT_LIBRARY) || - (t->second->GetType() == cmTarget::UTILITY)) + if(((*t)->GetType() == cmState::EXECUTABLE) || + ((*t)->GetType() == cmState::STATIC_LIBRARY) || + ((*t)->GetType() == cmState::SHARED_LIBRARY) || + ((*t)->GetType() == cmState::MODULE_LIBRARY) || + ((*t)->GetType() == cmState::OBJECT_LIBRARY) || + ((*t)->GetType() == cmState::UTILITY)) { - if (t->second->Target->IsImported()) - { - continue; - } - - emitted.insert(t->second->GetName()); + emitted.insert((*t)->GetName()); // for subdirs add a rule to build this specific target by name. - localName = this->GetRelativeTargetDirectory(*t->second->Target); + localName = this->GetRelativeTargetDirectory(*t); localName += "/rule"; commands.clear(); depends.clear(); @@ -449,54 +442,54 @@ void cmLocalUnixMakefileGenerator3 commands.push_back(this->GetRecursiveMakeCall (makefile2.c_str(),localName)); this->CreateCDCommand(commands, - this->Makefile->GetHomeOutputDirectory(), + this->GetBinaryDirectory(), cmLocalGenerator::START_OUTPUT); this->WriteMakeRule(ruleFileStream, "Convenience name for target.", localName, depends, commands, true); // Add a target with the canonical name (no prefix, suffix or path). - if(localName != t->second->GetName()) + if(localName != (*t)->GetName()) { commands.clear(); depends.push_back(localName); this->WriteMakeRule(ruleFileStream, "Convenience name for target.", - t->second->GetName(), depends, commands, true); + (*t)->GetName(), depends, commands, true); } // Add a fast rule to build the target std::string makefileName = - this->GetRelativeTargetDirectory(*t->second->Target); + this->GetRelativeTargetDirectory(*t); makefileName += "/build.make"; // make sure the makefile name is suitable for a makefile std::string makeTargetName = - this->GetRelativeTargetDirectory(*t->second->Target); + this->GetRelativeTargetDirectory(*t); makeTargetName += "/build"; - localName = t->second->GetName(); + localName = (*t)->GetName(); localName += "/fast"; depends.clear(); commands.clear(); commands.push_back(this->GetRecursiveMakeCall (makefileName.c_str(), makeTargetName)); this->CreateCDCommand(commands, - this->Makefile->GetHomeOutputDirectory(), + this->GetBinaryDirectory(), cmLocalGenerator::START_OUTPUT); this->WriteMakeRule(ruleFileStream, "fast build rule for target.", localName, depends, commands, true); // Add a local name for the rule to relink the target before // installation. - if(t->second->NeedRelinkBeforeInstall(this->ConfigName)) + if((*t)->NeedRelinkBeforeInstall(this->ConfigName)) { - makeTargetName = this->GetRelativeTargetDirectory(*t->second->Target); + makeTargetName = this->GetRelativeTargetDirectory(*t); makeTargetName += "/preinstall"; - localName = t->second->GetName(); + localName = (*t)->GetName(); localName += "/preinstall"; depends.clear(); commands.clear(); commands.push_back(this->GetRecursiveMakeCall (makefile2.c_str(), makeTargetName)); this->CreateCDCommand(commands, - this->Makefile->GetHomeOutputDirectory(), + this->GetBinaryDirectory(), cmLocalGenerator::START_OUTPUT); this->WriteMakeRule(ruleFileStream, "Manual pre-install relink rule for target.", @@ -509,7 +502,7 @@ void cmLocalUnixMakefileGenerator3 //---------------------------------------------------------------------------- void cmLocalUnixMakefileGenerator3::WriteDirectoryInformationFile() { - std::string infoFileName = this->Makefile->GetCurrentBinaryDirectory(); + std::string infoFileName = this->GetCurrentBinaryDirectory(); infoFileName += cmake::GetCMakeFilesDirectory(); infoFileName += "/CMakeDirectoryInformation.cmake"; @@ -573,7 +566,7 @@ std::string cmLocalUnixMakefileGenerator3 ::ConvertToFullPath(const std::string& localPath) { - std::string dir = this->Makefile->GetCurrentBinaryDirectory(); + std::string dir = this->GetCurrentBinaryDirectory(); dir += "/"; dir += localPath; return dir; @@ -750,13 +743,13 @@ cmLocalUnixMakefileGenerator3 makefileStream << "# The top-level source directory on which CMake was run.\n" << "CMAKE_SOURCE_DIR = " - << this->Convert(this->Makefile->GetHomeDirectory(), FULL, SHELL) + << this->Convert(this->GetSourceDirectory(), FULL, SHELL) << "\n" << "\n"; makefileStream << "# The top-level build directory on which CMake was run.\n" << "CMAKE_BINARY_DIR = " - << this->Convert(this->Makefile->GetHomeOutputDirectory(), FULL, SHELL) + << this->Convert(this->GetBinaryDirectory(), FULL, SHELL) << "\n" << "\n"; } @@ -886,10 +879,10 @@ void cmLocalUnixMakefileGenerator3 std::vector<std::string> no_depends; std::vector<std::string> commands; commands.push_back(runRule); - if(!this->GetMakefile()->IsRootMakefile()) + if(!this->IsRootMakefile()) { this->CreateCDCommand(commands, - this->Makefile->GetHomeOutputDirectory(), + this->GetBinaryDirectory(), cmLocalGenerator::START_OUTPUT); } this->WriteMakeRule(makefileStream, @@ -933,7 +926,7 @@ cmLocalUnixMakefileGenerator3 //---------------------------------------------------------------------------- std::string cmLocalUnixMakefileGenerator3 -::GetRelativeTargetDirectory(cmTarget const& target) +::GetRelativeTargetDirectory(cmGeneratorTarget* target) { std::string dir = this->HomeRelativeOutputPath; dir += this->GetTargetDirectory(target); @@ -1034,7 +1027,7 @@ void cmLocalUnixMakefileGenerator3 ::AppendCustomCommands(std::vector<std::string>& commands, const std::vector<cmCustomCommand>& ccs, - cmTarget* target, + cmGeneratorTarget* target, cmLocalGenerator::RelativeRoot relative) { for(std::vector<cmCustomCommand>::const_iterator i = ccs.begin(); @@ -1050,7 +1043,7 @@ void cmLocalUnixMakefileGenerator3 ::AppendCustomCommand(std::vector<std::string>& commands, cmCustomCommandGenerator const& ccg, - cmTarget* target, + cmGeneratorTarget* target, bool echo_comment, cmLocalGenerator::RelativeRoot relative, std::ostream* content) @@ -1070,7 +1063,7 @@ cmLocalUnixMakefileGenerator3 } // if the command specified a working directory use it. - std::string dir = this->Makefile->GetCurrentBinaryDirectory(); + std::string dir = this->GetCurrentBinaryDirectory(); std::string workingDir = ccg.GetWorkingDirectory(); if(!workingDir.empty()) { @@ -1181,7 +1174,7 @@ cmLocalUnixMakefileGenerator3 std::string cmLocalUnixMakefileGenerator3::MakeLauncher( cmCustomCommandGenerator const& ccg, - cmTarget* target, RelativeRoot relative) + cmGeneratorTarget* target, RelativeRoot relative) { // Short-circuit if there is no launcher. const char* prop = "RULE_LAUNCH_CUSTOM"; @@ -1218,9 +1211,9 @@ void cmLocalUnixMakefileGenerator3 ::AppendCleanCommand(std::vector<std::string>& commands, const std::vector<std::string>& files, - cmTarget& target, const char* filename) + cmGeneratorTarget* target, const char* filename) { - std::string cleanfile = this->Makefile->GetCurrentBinaryDirectory(); + std::string cleanfile = this->GetCurrentBinaryDirectory(); cleanfile += "/"; cleanfile += this->GetTargetDirectory(target); cleanfile += "/cmake_clean"; @@ -1256,9 +1249,7 @@ cmLocalUnixMakefileGenerator3 { // Get the set of source languages in the target. std::set<std::string> languages; - cmGeneratorTarget *gtgt = - this->GlobalGenerator->GetGeneratorTarget(&target); - gtgt->GetLanguages(languages, + target->GetLanguages(languages, this->Makefile->GetSafeDefinition("CMAKE_BUILD_TYPE")); fout << "\n" << "# Per-language clean rules from dependency scanning.\n" @@ -1501,7 +1492,7 @@ bool cmLocalUnixMakefileGenerator3::UpdateDependencies(const char* tgtInfo, // If the directory information is newer than depend.internal, include dirs // may have changed. In this case discard all old dependencies. bool needRescanDirInfo = false; - std::string dirInfoFile = this->Makefile->GetCurrentBinaryDirectory(); + std::string dirInfoFile = this->GetCurrentBinaryDirectory(); dirInfoFile += cmake::GetCMakeFilesDirectory(); dirInfoFile += "/CMakeDirectoryInformation.cmake"; { @@ -1575,7 +1566,7 @@ cmLocalUnixMakefileGenerator3 // Read the directory information file. cmMakefile* mf = this->Makefile; bool haveDirectoryInfo = false; - std::string dirInfoFile = this->Makefile->GetCurrentBinaryDirectory(); + std::string dirInfoFile = this->GetCurrentBinaryDirectory(); dirInfoFile += cmake::GetCMakeFilesDirectory(); dirInfoFile += "/CMakeDirectoryInformation.cmake"; if(mf->ReadListFile(dirInfoFile.c_str()) && @@ -1770,40 +1761,43 @@ void cmLocalUnixMakefileGenerator3 ruleFileStream << "# Targets provided globally by CMake.\n" << "\n"; - cmTargets* targets = &(this->Makefile->GetTargets()); - cmTargets::iterator glIt; - for ( glIt = targets->begin(); glIt != targets->end(); ++ glIt ) + std::vector<cmGeneratorTarget*> targets = this->GetGeneratorTargets(); + std::vector<cmGeneratorTarget*>::iterator glIt; + for ( glIt = targets.begin(); glIt != targets.end(); ++ glIt ) { - if ( glIt->second.GetType() == cmTarget::GLOBAL_TARGET ) + if ( (*glIt)->GetType() == cmState::GLOBAL_TARGET ) { - std::string targetString = "Special rule for the target " + glIt->first; + std::string targetString = "Special rule for the target " + + (*glIt)->GetName(); std::vector<std::string> commands; std::vector<std::string> depends; - const char* text = glIt->second.GetProperty("EchoString"); + const char* text = (*glIt)->GetProperty("EchoString"); if ( !text ) { text = "Running external command ..."; } - depends.insert(depends.end(), glIt->second.GetUtilities().begin(), - glIt->second.GetUtilities().end()); + depends.insert(depends.end(), (*glIt)->GetUtilities().begin(), + (*glIt)->GetUtilities().end()); this->AppendEcho(commands, text, cmLocalUnixMakefileGenerator3::EchoGlobal); + cmGeneratorTarget* gt = *glIt; + // Global targets store their rules in pre- and post-build commands. this->AppendCustomDepends(depends, - glIt->second.GetPreBuildCommands()); + gt->GetPreBuildCommands()); this->AppendCustomDepends(depends, - glIt->second.GetPostBuildCommands()); + gt->GetPostBuildCommands()); this->AppendCustomCommands(commands, - glIt->second.GetPreBuildCommands(), - &glIt->second, + gt->GetPreBuildCommands(), + gt, cmLocalGenerator::START_OUTPUT); this->AppendCustomCommands(commands, - glIt->second.GetPostBuildCommands(), - &glIt->second, + gt->GetPostBuildCommands(), + gt, cmLocalGenerator::START_OUTPUT); - std::string targetName = glIt->second.GetName(); + std::string targetName = gt->GetName(); this->WriteMakeRule(ruleFileStream, targetString.c_str(), targetName, depends, commands, true); @@ -1833,12 +1827,12 @@ void cmLocalUnixMakefileGenerator3 std::vector<std::string> commands; // Write the all rule. - std::string recursiveTarget = this->Makefile->GetCurrentBinaryDirectory(); + std::string recursiveTarget = this->GetCurrentBinaryDirectory(); recursiveTarget += "/all"; depends.push_back("cmake_check_build_system"); - std::string progressDir = this->Makefile->GetHomeOutputDirectory(); + std::string progressDir = this->GetBinaryDirectory(); progressDir += cmake::GetCMakeFilesDirectory(); { std::ostringstream progCmd; @@ -1862,7 +1856,7 @@ void cmLocalUnixMakefileGenerator3 commands.push_back(this->GetRecursiveMakeCall(mf2Dir.c_str(), recursiveTarget)); this->CreateCDCommand(commands, - this->Makefile->GetHomeOutputDirectory(), + this->GetBinaryDirectory(), cmLocalGenerator::START_OUTPUT); { std::ostringstream progCmd; @@ -1877,14 +1871,14 @@ void cmLocalUnixMakefileGenerator3 depends, commands, true); // Write the clean rule. - recursiveTarget = this->Makefile->GetCurrentBinaryDirectory(); + recursiveTarget = this->GetCurrentBinaryDirectory(); recursiveTarget += "/clean"; commands.clear(); depends.clear(); commands.push_back(this->GetRecursiveMakeCall(mf2Dir.c_str(), recursiveTarget)); this->CreateCDCommand(commands, - this->Makefile->GetHomeOutputDirectory(), + this->GetBinaryDirectory(), cmLocalGenerator::START_OUTPUT); this->WriteMakeRule(ruleFileStream, "The main clean target", "clean", depends, commands, true); @@ -1895,7 +1889,7 @@ void cmLocalUnixMakefileGenerator3 depends, commands, true); // Write the preinstall rule. - recursiveTarget = this->Makefile->GetCurrentBinaryDirectory(); + recursiveTarget = this->GetCurrentBinaryDirectory(); recursiveTarget += "/preinstall"; commands.clear(); depends.clear(); @@ -1914,7 +1908,7 @@ void cmLocalUnixMakefileGenerator3 commands.push_back (this->GetRecursiveMakeCall(mf2Dir.c_str(), recursiveTarget)); this->CreateCDCommand(commands, - this->Makefile->GetHomeOutputDirectory(), + this->GetBinaryDirectory(), cmLocalGenerator::START_OUTPUT); this->WriteMakeRule(ruleFileStream, "Prepare targets for installation.", "preinstall", depends, commands, true); @@ -1935,7 +1929,7 @@ void cmLocalUnixMakefileGenerator3 runRule += " 1"; commands.push_back(runRule); this->CreateCDCommand(commands, - this->Makefile->GetHomeOutputDirectory(), + this->GetBinaryDirectory(), cmLocalGenerator::START_OUTPUT); this->WriteMakeRule(ruleFileStream, "clear depends", "depend", @@ -1978,7 +1972,8 @@ void cmLocalUnixMakefileGenerator3::ClearDependencies(cmMakefile* mf, void cmLocalUnixMakefileGenerator3 -::WriteDependLanguageInfo(std::ostream& cmakefileStream, cmTarget &target) +::WriteDependLanguageInfo(std::ostream& cmakefileStream, + cmGeneratorTarget* target) { ImplicitDependLanguageMap const& implicitLangs = this->GetImplicitDepends(target); @@ -2032,7 +2027,7 @@ void cmLocalUnixMakefileGenerator3 // Build a list of preprocessor definitions for the target. std::set<std::string> defines; - this->AddCompileDefinitions(defines, &target, + this->AddCompileDefinitions(defines, target, this->ConfigName, l->first); if(!defines.empty()) { @@ -2058,12 +2053,10 @@ void cmLocalUnixMakefileGenerator3 << "set(CMAKE_" << l->first << "_TARGET_INCLUDE_PATH\n"; std::vector<std::string> includes; - cmGeneratorTarget* gt = this->GetGlobalGenerator() - ->GetGeneratorTarget(&target); const std::string& config = this->Makefile->GetSafeDefinition("CMAKE_BUILD_TYPE"); - this->GetIncludeDirectories(includes, gt, + this->GetIncludeDirectories(includes, target, l->first, config); for(std::vector<std::string>::iterator i = includes.begin(); i != includes.end(); ++i) @@ -2086,7 +2079,7 @@ void cmLocalUnixMakefileGenerator3 cmSystemTools::ExpandListArgument(xform, transformRules); } if(const char* xform = - target.GetProperty("IMPLICIT_DEPENDS_INCLUDE_TRANSFORM")) + target->GetProperty("IMPLICIT_DEPENDS_INCLUDE_TRANSFORM")) { cmSystemTools::ExpandListArgument(xform, transformRules); } @@ -2284,10 +2277,10 @@ cmLocalUnixMakefileGenerator3::ConvertToQuotedOutputPath(const char* p, //---------------------------------------------------------------------------- std::string cmLocalUnixMakefileGenerator3 -::GetTargetDirectory(cmTarget const& target) const +::GetTargetDirectory(cmGeneratorTarget const* target) const { std::string dir = cmake::GetCMakeFilesDirectoryPostSlash(); - dir += target.GetName(); + dir += target->GetName(); #if defined(__VMS) dir += "_dir"; #else @@ -2298,19 +2291,20 @@ cmLocalUnixMakefileGenerator3 //---------------------------------------------------------------------------- cmLocalUnixMakefileGenerator3::ImplicitDependLanguageMap const& -cmLocalUnixMakefileGenerator3::GetImplicitDepends(cmTarget const& tgt) +cmLocalUnixMakefileGenerator3::GetImplicitDepends( + const cmGeneratorTarget* tgt) { - return this->ImplicitDepends[tgt.GetName()]; + return this->ImplicitDepends[tgt->GetName()]; } //---------------------------------------------------------------------------- void -cmLocalUnixMakefileGenerator3::AddImplicitDepends(cmTarget const& tgt, +cmLocalUnixMakefileGenerator3::AddImplicitDepends(const cmGeneratorTarget* tgt, const std::string& lang, const char* obj, const char* src) { - this->ImplicitDepends[tgt.GetName()][lang][obj].push_back(src); + this->ImplicitDepends[tgt->GetName()][lang][obj].push_back(src); } //---------------------------------------------------------------------------- diff --git a/Source/cmLocalUnixMakefileGenerator3.h b/Source/cmLocalUnixMakefileGenerator3.h index 98f15e6..8f69311 100644 --- a/Source/cmLocalUnixMakefileGenerator3.h +++ b/Source/cmLocalUnixMakefileGenerator3.h @@ -19,10 +19,8 @@ class cmCustomCommand; class cmCustomCommandGenerator; -class cmDependInformation; class cmDepends; class cmMakefileTargetGenerator; -class cmTarget; class cmSourceFile; /** \class cmLocalUnixMakefileGenerator3 @@ -106,7 +104,8 @@ public: /** Get whether the makefile is to have color. */ bool GetColorMakefile() const { return this->ColorMakefile; } - virtual std::string GetTargetDirectory(cmTarget const& target) const; + virtual + std::string GetTargetDirectory(cmGeneratorTarget const* target) const; // create a command that cds to the start dir then runs the commands void CreateCDCommand(std::vector<std::string>& commands, @@ -131,7 +130,7 @@ public: void WriteSpecialTargetsTop(std::ostream& makefileStream); void WriteSpecialTargetsBottom(std::ostream& makefileStream); - std::string GetRelativeTargetDirectory(cmTarget const& target); + std::string GetRelativeTargetDirectory(cmGeneratorTarget* target); // File pairs for implicit dependency scanning. The key of the map // is the depender and the value is the explicit dependee. @@ -141,9 +140,11 @@ public: public std::map<std::string, ImplicitDependFileMap> {}; struct ImplicitDependTargetMap: public std::map<std::string, ImplicitDependLanguageMap> {}; - ImplicitDependLanguageMap const& GetImplicitDepends(cmTarget const& tgt); + ImplicitDependLanguageMap const& + GetImplicitDepends(cmGeneratorTarget const* tgt); - void AddImplicitDepends(cmTarget const& tgt, const std::string& lang, + void AddImplicitDepends(cmGeneratorTarget const* tgt, + const std::string& lang, const char* obj, const char* src); // write the target rules for the local Makefile into the stream @@ -181,7 +182,8 @@ protected: // write the depend info - void WriteDependLanguageInfo(std::ostream& cmakefileStream, cmTarget &tgt); + void WriteDependLanguageInfo(std::ostream& cmakefileStream, + cmGeneratorTarget *tgt); // write the local help rule void WriteHelpRule(std::ostream& ruleFileStream); @@ -196,12 +198,12 @@ protected: const std::string& helpTarget); void WriteTargetDependRule(std::ostream& ruleFileStream, - cmTarget& target); + cmGeneratorTarget* target); void WriteTargetCleanRule(std::ostream& ruleFileStream, - cmTarget& target, + cmGeneratorTarget* target, const std::vector<std::string>& files); void WriteTargetRequiresRule(std::ostream& ruleFileStream, - cmTarget& target, + cmGeneratorTarget* target, const std::vector<std::string>& objects); void AppendRuleDepend(std::vector<std::string>& depends, @@ -214,19 +216,19 @@ protected: cmCustomCommandGenerator const& cc); void AppendCustomCommands(std::vector<std::string>& commands, const std::vector<cmCustomCommand>& ccs, - cmTarget* target, + cmGeneratorTarget* target, cmLocalGenerator::RelativeRoot relative = cmLocalGenerator::HOME_OUTPUT); void AppendCustomCommand(std::vector<std::string>& commands, cmCustomCommandGenerator const& ccg, - cmTarget* target, + cmGeneratorTarget* target, bool echo_comment=false, cmLocalGenerator::RelativeRoot relative = cmLocalGenerator::HOME_OUTPUT, std::ostream* content = 0); void AppendCleanCommand(std::vector<std::string>& commands, const std::vector<std::string>& files, - cmTarget& target, const char* filename =0); + cmGeneratorTarget* target, const char* filename =0); // Helper methods for dependeny updates. bool ScanDependencies(const char* targetDir, @@ -236,7 +238,7 @@ protected: private: std::string ConvertShellCommand(std::string const& cmd, RelativeRoot root); std::string MakeLauncher(cmCustomCommandGenerator const& ccg, - cmTarget* target, RelativeRoot relative); + cmGeneratorTarget* target, RelativeRoot relative); virtual void ComputeObjectFilenames( std::map<cmSourceFile const*, std::string>& mapping, @@ -254,10 +256,10 @@ private: struct LocalObjectEntry { - cmTarget* Target; + cmGeneratorTarget* Target; std::string Language; LocalObjectEntry(): Target(0), Language() {} - LocalObjectEntry(cmTarget* t, const std::string& lang): + LocalObjectEntry(cmGeneratorTarget* t, const std::string& lang): Target(t), Language(lang) {} }; struct LocalObjectInfo: public std::vector<LocalObjectEntry> diff --git a/Source/cmLocalVisualStudio10Generator.cxx b/Source/cmLocalVisualStudio10Generator.cxx index b043b00..d0784ad 100644 --- a/Source/cmLocalVisualStudio10Generator.cxx +++ b/Source/cmLocalVisualStudio10Generator.cxx @@ -10,7 +10,6 @@ See the License for more information. ============================================================================*/ #include "cmLocalVisualStudio10Generator.h" -#include "cmTarget.h" #include "cmMakefile.h" #include "cmVisualStudio10TargetGenerator.h" #include "cmGlobalVisualStudio10Generator.h" @@ -74,22 +73,23 @@ cmLocalVisualStudio10Generator::~cmLocalVisualStudio10Generator() void cmLocalVisualStudio10Generator::Generate() { - cmTargets &tgts = this->Makefile->GetTargets(); - for(cmTargets::iterator l = tgts.begin(); l != tgts.end(); ++l) + std::vector<cmGeneratorTarget*> tgts = this->GetGeneratorTargets(); + for(std::vector<cmGeneratorTarget*>::iterator l = tgts.begin(); + l != tgts.end(); ++l) { - if(l->second.GetType() == cmTarget::INTERFACE_LIBRARY) + if((*l)->GetType() == cmState::INTERFACE_LIBRARY) { continue; } if(static_cast<cmGlobalVisualStudioGenerator*>(this->GlobalGenerator) - ->TargetIsFortranOnly(l->second)) + ->TargetIsFortranOnly(*l)) { - this->CreateSingleVCProj(l->first.c_str(),l->second); + this->CreateSingleVCProj((*l)->GetName().c_str(), *l); } else { cmVisualStudio10TargetGenerator tg( - &l->second, static_cast<cmGlobalVisualStudio10Generator*>( + *l, static_cast<cmGlobalVisualStudio10Generator*>( this->GetGlobalGenerator())); tg.Generate(); } diff --git a/Source/cmLocalVisualStudio6Generator.cxx b/Source/cmLocalVisualStudio6Generator.cxx index cc94cd4..cdacb9e 100644 --- a/Source/cmLocalVisualStudio6Generator.cxx +++ b/Source/cmLocalVisualStudio6Generator.cxx @@ -82,12 +82,12 @@ private: void cmLocalVisualStudio6Generator::AddCMakeListsRules() { - cmTargets &tgts = this->Makefile->GetTargets(); - for(cmTargets::iterator l = tgts.begin(); - l != tgts.end(); l++) + std::vector<cmGeneratorTarget*> tgts = this->GetGeneratorTargets(); + for(std::vector<cmGeneratorTarget*>::iterator l = tgts.begin(); + l != tgts.end(); ++l) { - if (l->second.GetType() == cmTarget::INTERFACE_LIBRARY - || l->second.GetType() == cmTarget::GLOBAL_TARGET) + if ((*l)->GetType() == cmState::INTERFACE_LIBRARY + || (*l)->GetType() == cmState::GLOBAL_TARGET) { continue; } @@ -98,7 +98,7 @@ void cmLocalVisualStudio6Generator::AddCMakeListsRules() this->Makefile->GetDefinition("CMAKE_SUPPRESS_REGENERATION"); if (!cmSystemTools::IsOn(suppRegenRule)) { - this->AddDSPBuildRule(l->second); + this->AddDSPBuildRule(*l); } } } @@ -111,67 +111,69 @@ void cmLocalVisualStudio6Generator::Generate() void cmLocalVisualStudio6Generator::OutputDSPFile() { // If not an in source build, then create the output directory - if(strcmp(this->Makefile->GetCurrentBinaryDirectory(), - this->Makefile->GetHomeDirectory()) != 0) + if(strcmp(this->GetCurrentBinaryDirectory(), + this->GetSourceDirectory()) != 0) { if(!cmSystemTools::MakeDirectory - (this->Makefile->GetCurrentBinaryDirectory())) + (this->GetCurrentBinaryDirectory())) { cmSystemTools::Error("Error creating directory ", - this->Makefile->GetCurrentBinaryDirectory()); + this->GetCurrentBinaryDirectory()); } } // Create the DSP or set of DSP's for libraries and executables - cmTargets &tgts = this->Makefile->GetTargets(); - - // build any targets - for(cmTargets::iterator l = tgts.begin(); - l != tgts.end(); l++) + std::vector<cmGeneratorTarget*> tgts = this->GetGeneratorTargets(); + for(std::vector<cmGeneratorTarget*>::iterator l = tgts.begin(); + l != tgts.end(); ++l) { - switch(l->second.GetType()) + switch((*l)->GetType()) { - case cmTarget::STATIC_LIBRARY: - case cmTarget::OBJECT_LIBRARY: - this->SetBuildType(STATIC_LIBRARY, l->first.c_str(), l->second); + case cmState::STATIC_LIBRARY: + case cmState::OBJECT_LIBRARY: + this->SetBuildType(STATIC_LIBRARY, + (*l)->GetName().c_str(), *l); break; - case cmTarget::SHARED_LIBRARY: - case cmTarget::MODULE_LIBRARY: - this->SetBuildType(DLL, l->first.c_str(), l->second); + case cmState::SHARED_LIBRARY: + case cmState::MODULE_LIBRARY: + this->SetBuildType(DLL, + (*l)->GetName().c_str(), *l); break; - case cmTarget::EXECUTABLE: - this->SetBuildType(EXECUTABLE,l->first.c_str(), l->second); + case cmState::EXECUTABLE: + this->SetBuildType(EXECUTABLE, + (*l)->GetName().c_str(), *l); break; - case cmTarget::UTILITY: - case cmTarget::GLOBAL_TARGET: - this->SetBuildType(UTILITY, l->first.c_str(), l->second); + case cmState::UTILITY: + case cmState::GLOBAL_TARGET: + this->SetBuildType(UTILITY, + (*l)->GetName().c_str(), *l); break; - case cmTarget::INTERFACE_LIBRARY: + case cmState::INTERFACE_LIBRARY: continue; default: - cmSystemTools::Error("Bad target type: ", l->first.c_str()); + cmSystemTools::Error("Bad target type: ", (*l)->GetName().c_str()); break; } // INCLUDE_EXTERNAL_MSPROJECT command only affects the workspace // so don't build a projectfile for it const char* path = - l->second.GetProperty("EXTERNAL_MSPROJECT"); + (*l)->GetProperty("EXTERNAL_MSPROJECT"); if(!path) { // check to see if the dsp is going into a sub-directory - std::string::size_type pos = l->first.rfind('/'); + std::string::size_type pos = (*l)->GetName().rfind('/'); if(pos != std::string::npos) { - std::string dir = this->Makefile->GetCurrentBinaryDirectory(); + std::string dir = this->GetCurrentBinaryDirectory(); dir += "/"; - dir += l->first.substr(0, pos); + dir += (*l)->GetName().substr(0, pos); if(!cmSystemTools::MakeDirectory(dir.c_str())) { cmSystemTools::Error("Error creating directory: ", dir.c_str()); } } - this->CreateSingleDSP(l->first.c_str(),l->second); + this->CreateSingleDSP((*l)->GetName().c_str(), *l); } } } @@ -182,14 +184,14 @@ void cmLocalVisualStudio6Generator::OutputDSPFile() extern std::string GetVS6TargetName(const std::string& targetName); void cmLocalVisualStudio6Generator::CreateSingleDSP(const std::string& lname, - cmTarget &target) + cmGeneratorTarget* target) { // add to the list of projects std::string pname = GetVS6TargetName(lname); // create the dsp.cmake file std::string fname; - fname = this->Makefile->GetCurrentBinaryDirectory(); + fname = this->GetCurrentBinaryDirectory(); fname += "/"; fname += pname; fname += ".dsp"; @@ -209,13 +211,13 @@ void cmLocalVisualStudio6Generator::CreateSingleDSP(const std::string& lname, } -void cmLocalVisualStudio6Generator::AddDSPBuildRule(cmTarget& tgt) +void cmLocalVisualStudio6Generator::AddDSPBuildRule(cmGeneratorTarget *tgt) { - std::string dspname = GetVS6TargetName(tgt.GetName()); + std::string dspname = GetVS6TargetName(tgt->GetName()); dspname += ".dsp.cmake"; cmCustomCommandLine commandLine; commandLine.push_back(cmSystemTools::GetCMakeCommand()); - std::string makefileIn = this->Makefile->GetCurrentSourceDirectory(); + std::string makefileIn = this->GetCurrentSourceDirectory(); makefileIn += "/"; makefileIn += "CMakeLists.txt"; if(!cmSystemTools::FileExists(makefileIn.c_str())) @@ -226,10 +228,10 @@ void cmLocalVisualStudio6Generator::AddDSPBuildRule(cmTarget& tgt) comment += makefileIn; std::string args; args = "-H"; - args += this->Makefile->GetHomeDirectory(); + args += this->GetSourceDirectory(); commandLine.push_back(args); args = "-B"; - args += this->Makefile->GetHomeOutputDirectory(); + args += this->GetBinaryDirectory(); commandLine.push_back(args); std::vector<std::string> const& listFiles = this->Makefile->GetListFiles(); @@ -243,7 +245,7 @@ void cmLocalVisualStudio6Generator::AddDSPBuildRule(cmTarget& tgt) no_working_directory, true); if(this->Makefile->GetSource(makefileIn.c_str())) { - tgt.AddSource(makefileIn); + tgt->AddSource(makefileIn); } else { @@ -254,7 +256,7 @@ void cmLocalVisualStudio6Generator::AddDSPBuildRule(cmTarget& tgt) void cmLocalVisualStudio6Generator::WriteDSPFile(std::ostream& fout, const std::string& libName, - cmTarget &target) + cmGeneratorTarget *target) { // For utility targets need custom command since pre- and post- // build does not do anything in Visual Studio 6. In order for the @@ -262,23 +264,23 @@ void cmLocalVisualStudio6Generator::WriteDSPFile(std::ostream& fout, // special care for dependencies. The first rule must depend on all // the dependencies of all the rules. The later rules must each // depend only on the previous rule. - if ((target.GetType() == cmTarget::UTILITY || - target.GetType() == cmTarget::GLOBAL_TARGET) && - (!target.GetPreBuildCommands().empty() || - !target.GetPostBuildCommands().empty())) + if ((target->GetType() == cmState::UTILITY || + target->GetType() == cmState::GLOBAL_TARGET) && + (!target->GetPreBuildCommands().empty() || + !target->GetPostBuildCommands().empty())) { // Accumulate the dependencies of all the commands. std::vector<std::string> depends; for (std::vector<cmCustomCommand>::const_iterator cr = - target.GetPreBuildCommands().begin(); - cr != target.GetPreBuildCommands().end(); ++cr) + target->GetPreBuildCommands().begin(); + cr != target->GetPreBuildCommands().end(); ++cr) { depends.insert(depends.end(), cr->GetDepends().begin(), cr->GetDepends().end()); } for (std::vector<cmCustomCommand>::const_iterator cr = - target.GetPostBuildCommands().begin(); - cr != target.GetPostBuildCommands().end(); ++cr) + target->GetPostBuildCommands().begin(); + cr != target->GetPostBuildCommands().end(); ++cr) { depends.insert(depends.end(), cr->GetDepends().begin(), cr->GetDepends().end()); @@ -287,14 +289,14 @@ void cmLocalVisualStudio6Generator::WriteDSPFile(std::ostream& fout, // Add the pre- and post-build commands in order. int count = 1; for (std::vector<cmCustomCommand>::const_iterator cr = - target.GetPreBuildCommands().begin(); - cr != target.GetPreBuildCommands().end(); ++cr) + target->GetPreBuildCommands().begin(); + cr != target->GetPreBuildCommands().end(); ++cr) { this->AddUtilityCommandHack(target, count++, depends, *cr); } for (std::vector<cmCustomCommand>::const_iterator cr = - target.GetPostBuildCommands().begin(); - cr != target.GetPostBuildCommands().end(); ++cr) + target->GetPostBuildCommands().begin(); + cr != target->GetPostBuildCommands().end(); ++cr) { this->AddUtilityCommandHack(target, count++, depends, *cr); } @@ -303,12 +305,9 @@ void cmLocalVisualStudio6Generator::WriteDSPFile(std::ostream& fout, // We may be modifying the source groups temporarily, so make a copy. std::vector<cmSourceGroup> sourceGroups = this->Makefile->GetSourceGroups(); - cmGeneratorTarget* gt = - this->GlobalGenerator->GetGeneratorTarget(&target); - // get the classes from the source lists then add them to the groups std::vector<cmSourceFile*> classes; - if (!gt->GetConfigCommonSourceFiles(classes)) + if (!target->GetConfigCommonSourceFiles(classes)) { return; } @@ -372,11 +371,9 @@ void cmLocalVisualStudio6Generator::WriteDSPFile(std::ostream& fout, } void cmLocalVisualStudio6Generator -::WriteGroup(const cmSourceGroup *sg, cmTarget& target, +::WriteGroup(const cmSourceGroup *sg, cmGeneratorTarget* target, std::ostream &fout, const std::string& libName) { - cmGeneratorTarget* gt = - this->GlobalGenerator->GetGeneratorTarget(&target); const std::vector<const cmSourceFile *> &sourceFiles = sg->GetSourceFiles(); // If the group is empty, don't write it at all. @@ -408,9 +405,10 @@ void cmLocalVisualStudio6Generator std::string compileFlags; std::vector<std::string> depends; std::string objectNameDir; - if(gt->HasExplicitObjectName(*sf)) + if(target->HasExplicitObjectName(*sf)) { - objectNameDir = cmSystemTools::GetFilenamePath(gt->GetObjectName(*sf)); + objectNameDir = + cmSystemTools::GetFilenamePath(target->GetObjectName(*sf)); } // Add per-source file flags. @@ -481,8 +479,8 @@ void cmLocalVisualStudio6Generator cmSystemTools::ExpandListArgument(dependsValue, depends); } if (GetVS6TargetName(source) != libName || - target.GetType() == cmTarget::UTILITY || - target.GetType() == cmTarget::GLOBAL_TARGET) + target->GetType() == cmState::UTILITY || + target->GetType() == cmState::GLOBAL_TARGET) { fout << "# Begin Source File\n\n"; @@ -572,15 +570,15 @@ void cmLocalVisualStudio6Generator void cmLocalVisualStudio6Generator -::AddUtilityCommandHack(cmTarget& target, int count, +::AddUtilityCommandHack(cmGeneratorTarget *target, int count, std::vector<std::string>& depends, const cmCustomCommand& origCommand) { // Create a fake output that forces the rule to run. - char* output = new char[(strlen(this->Makefile->GetCurrentBinaryDirectory()) - + target.GetName().size() + 30)]; - sprintf(output,"%s/%s_force_%i", this->Makefile->GetCurrentBinaryDirectory(), - target.GetName().c_str(), count); + char* output = new char[(strlen(this->GetCurrentBinaryDirectory()) + + target->GetName().size() + 30)]; + sprintf(output,"%s/%s_force_%i", this->GetCurrentBinaryDirectory(), + target->GetName().c_str(), count); const char* comment = origCommand.GetComment(); if(!comment && origCommand.GetOutputs().empty()) { @@ -595,7 +593,7 @@ cmLocalVisualStudio6Generator origCommand.GetCommandLines(), comment, origCommand.GetWorkingDirectory().c_str())) { - target.AddSource(outsf->GetFullPath()); + target->AddSource(outsf->GetFullPath()); } // Replace the dependencies with the output of this rule so that the @@ -711,7 +709,7 @@ void cmLocalVisualStudio6Generator::WriteDSPEndGroup(std::ostream& fout) void cmLocalVisualStudio6Generator::SetBuildType(BuildType b, const std::string& libName, - cmTarget& target) + cmGeneratorTarget *target) { std::string root= this->Makefile->GetRequiredDefinition("CMAKE_ROOT"); const char *def= @@ -743,7 +741,7 @@ void cmLocalVisualStudio6Generator::SetBuildType(BuildType b, this->DSPFooterTemplate += "/DLLFooter.dsptemplate"; break; case EXECUTABLE: - if ( target.GetPropertyAsBool("WIN32_EXECUTABLE") ) + if ( target->GetPropertyAsBool("WIN32_EXECUTABLE") ) { this->DSPHeaderTemplate = root; this->DSPHeaderTemplate += "/EXEWinHeader.dsptemplate"; @@ -795,15 +793,16 @@ void cmLocalVisualStudio6Generator::SetBuildType(BuildType b, //---------------------------------------------------------------------------- cmsys::auto_ptr<cmCustomCommand> -cmLocalVisualStudio6Generator::MaybeCreateOutputDir(cmTarget& target, +cmLocalVisualStudio6Generator::MaybeCreateOutputDir(cmGeneratorTarget* target, const std::string& config) { cmsys::auto_ptr<cmCustomCommand> pcc; // VS6 forgets to create the output directory for archives if it // differs from the intermediate directory. - if(target.GetType() != cmTarget::STATIC_LIBRARY) { return pcc; } - std::string outDir = target.GetDirectory(config, false); + if(target->GetType() != cmState::STATIC_LIBRARY) { return pcc; } + + std::string outDir = target->GetDirectory(config, false); // Add a pre-link event to create the directory. cmCustomCommandLine command; @@ -825,11 +824,11 @@ cmLocalVisualStudio6Generator::MaybeCreateOutputDir(cmTarget& target, // look for custom rules on a target and collect them together std::string -cmLocalVisualStudio6Generator::CreateTargetRules(cmTarget &target, +cmLocalVisualStudio6Generator::CreateTargetRules(cmGeneratorTarget *target, const std::string& configName, const std::string& /* libName */) { - if (target.GetType() >= cmTarget::UTILITY ) + if (target->GetType() >= cmState::UTILITY ) { return ""; } @@ -839,8 +838,8 @@ cmLocalVisualStudio6Generator::CreateTargetRules(cmTarget &target, // Write the pre-build and pre-link together (VS6 does not support both). event.Start("PreLink"); - event.Write(target.GetPreBuildCommands()); - event.Write(target.GetPreLinkCommands()); + event.Write(target->GetPreBuildCommands()); + event.Write(target->GetPreLinkCommands()); cmsys::auto_ptr<cmCustomCommand> pcc( this->MaybeCreateImplibDir(target, configName, false)); if(pcc.get()) @@ -856,7 +855,7 @@ cmLocalVisualStudio6Generator::CreateTargetRules(cmTarget &target, // Write the post-build rules. event.Start("PostBuild"); - event.Write(target.GetPostBuildCommands()); + event.Write(target->GetPostBuildCommands()); event.Finish(); customRuleCode += "# End Special Build Tool\n"; @@ -875,7 +874,8 @@ inline std::string removeQuotes(const std::string& s) std::string -cmLocalVisualStudio6Generator::GetTargetIncludeOptions(cmTarget &target, +cmLocalVisualStudio6Generator::GetTargetIncludeOptions( + cmGeneratorTarget *target, const std::string& config) { std::string includeOptions; @@ -886,12 +886,10 @@ cmLocalVisualStudio6Generator::GetTargetIncludeOptions(cmTarget &target, unsigned int maxIncludeLength = 3000; bool useShortPath = false; - cmGeneratorTarget* gt = - this->GlobalGenerator->GetGeneratorTarget(&target); for(int j=0; j < 2; ++j) { std::vector<std::string> includes; - this->GetIncludeDirectories(includes, gt, "C", config); + this->GetIncludeDirectories(includes, target, "C", config); std::vector<std::string>::iterator i; for(i = includes.begin(); i != includes.end(); ++i) @@ -939,11 +937,11 @@ cmLocalVisualStudio6Generator::GetTargetIncludeOptions(cmTarget &target, void cmLocalVisualStudio6Generator ::WriteDSPHeader(std::ostream& fout, - const std::string& libName, cmTarget &target, + const std::string& libName, cmGeneratorTarget* target, std::vector<cmSourceGroup> &) { - bool targetBuilds = (target.GetType() >= cmTarget::EXECUTABLE && - target.GetType() <= cmTarget::MODULE_LIBRARY); + bool targetBuilds = (target->GetType() >= cmState::EXECUTABLE && + target->GetType() <= cmState::MODULE_LIBRARY); #ifdef CM_USE_OLD_VS6 // Lookup the library and executable output directories. std::string libPath; @@ -1053,7 +1051,8 @@ void cmLocalVisualStudio6Generator } } std::vector<std::string>::const_iterator i; - const std::vector<std::string>& libdirs = target.GetLinkDirectories(); + const std::vector<std::string>& libdirs = + target->GetLinkDirectories(); for(i = libdirs.begin(); i != libdirs.end(); ++i) { std::string path = *i; @@ -1095,33 +1094,32 @@ void cmLocalVisualStudio6Generator } // find link libraries const cmTarget::LinkLibraryVectorType& libs = - target.GetLinkLibrariesForVS6(); + target->Target->GetLinkLibrariesForVS6(); cmTarget::LinkLibraryVectorType::const_iterator j; for(j = libs.begin(); j != libs.end(); ++j) { // add libraries to executables and dlls (but never include // a library in a library, bad recursion) // NEVER LINK STATIC LIBRARIES TO OTHER STATIC LIBRARIES - if ((target.GetType() != cmTarget::SHARED_LIBRARY - && target.GetType() != cmTarget::STATIC_LIBRARY - && target.GetType() != cmTarget::MODULE_LIBRARY) || - (target.GetType()==cmTarget::SHARED_LIBRARY + if ((target->GetType() != cmState::SHARED_LIBRARY + && target->GetType() != cmState::STATIC_LIBRARY + && target->GetType() != cmState::MODULE_LIBRARY) || + (target->GetType()==cmState::SHARED_LIBRARY && libName != GetVS6TargetName(j->first)) || - (target.GetType()==cmTarget::MODULE_LIBRARY + (target->GetType()==cmState::MODULE_LIBRARY && libName != GetVS6TargetName(j->first))) { // Compute the proper name to use to link this library. std::string lib; std::string libDebug; - cmTarget* tgt = this->GlobalGenerator->FindTarget(j->first.c_str()); + cmGeneratorTarget* tgt = + this->GlobalGenerator->FindGeneratorTarget(j->first.c_str()); if(tgt) { - cmGeneratorTarget* gt = - this->GlobalGenerator->GetGeneratorTarget(tgt); lib = cmSystemTools::GetFilenameWithoutExtension - (gt->GetFullName().c_str()); + (tgt->GetFullName().c_str()); libDebug = cmSystemTools::GetFilenameWithoutExtension - (gt->GetFullName("Debug").c_str()); + (tgt->GetFullName("Debug").c_str()); lib += ".lib"; libDebug += ".lib"; } @@ -1139,7 +1137,7 @@ void cmLocalVisualStudio6Generator libDebug = this->ConvertToOutputFormat(libDebug.c_str(), SHELL); - if (j->second == cmTarget::GENERAL) + if (j->second == GENERAL_LibraryType) { libOptions += " "; libOptions += lib; @@ -1150,7 +1148,7 @@ void cmLocalVisualStudio6Generator libMultiLineOptionsForDebug += libDebug; libMultiLineOptionsForDebug += "\n"; } - if (j->second == cmTarget::DEBUG) + if (j->second == DEBUG_LibraryType) { libDebugOptions += " "; libDebugOptions += lib; @@ -1159,7 +1157,7 @@ void cmLocalVisualStudio6Generator libMultiLineDebugOptions += libDebug; libMultiLineDebugOptions += "\n"; } - if (j->second == cmTarget::OPTIMIZED) + if (j->second == OPTIMIZED_LibraryType) { libOptimizedOptions += " "; libOptimizedOptions += lib; @@ -1189,7 +1187,7 @@ void cmLocalVisualStudio6Generator std::string extraLinkOptionsRelease; std::string extraLinkOptionsMinSizeRel; std::string extraLinkOptionsRelWithDebInfo; - if(target.GetType() == cmTarget::EXECUTABLE) + if(target->GetType() == cmState::EXECUTABLE) { extraLinkOptions = this->Makefile-> GetRequiredDefinition("CMAKE_EXE_LINKER_FLAGS"); @@ -1202,7 +1200,7 @@ void cmLocalVisualStudio6Generator extraLinkOptionsRelWithDebInfo = this->Makefile-> GetRequiredDefinition("CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO"); } - if(target.GetType() == cmTarget::SHARED_LIBRARY) + if(target->GetType() == cmState::SHARED_LIBRARY) { extraLinkOptions = this->Makefile-> GetRequiredDefinition("CMAKE_SHARED_LINKER_FLAGS"); @@ -1215,7 +1213,7 @@ void cmLocalVisualStudio6Generator extraLinkOptionsRelWithDebInfo = this->Makefile-> GetRequiredDefinition("CMAKE_SHARED_LINKER_FLAGS_RELWITHDEBINFO"); } - if(target.GetType() == cmTarget::MODULE_LIBRARY) + if(target->GetType() == cmState::MODULE_LIBRARY) { extraLinkOptions = this->Makefile-> GetRequiredDefinition("CMAKE_MODULE_LINKER_FLAGS"); @@ -1230,63 +1228,61 @@ void cmLocalVisualStudio6Generator } // Get extra linker options for this target. - if(const char* targetLinkFlags = target.GetProperty("LINK_FLAGS")) + if(const char* targetLinkFlags = target->GetProperty("LINK_FLAGS")) { extraLinkOptions += " "; extraLinkOptions += targetLinkFlags; } - if(const char* targetLinkFlags = target.GetProperty("LINK_FLAGS_DEBUG")) + if(const char* targetLinkFlags = target->GetProperty("LINK_FLAGS_DEBUG")) { extraLinkOptionsDebug += " "; extraLinkOptionsDebug += targetLinkFlags; } - if(const char* targetLinkFlags = target.GetProperty("LINK_FLAGS_RELEASE")) + if(const char* targetLinkFlags = target->GetProperty("LINK_FLAGS_RELEASE")) { extraLinkOptionsRelease += " "; extraLinkOptionsRelease += targetLinkFlags; } - if(const char* targetLinkFlags = target.GetProperty("LINK_FLAGS_MINSIZEREL")) + if(const char* targetLinkFlags = + target->GetProperty("LINK_FLAGS_MINSIZEREL")) { extraLinkOptionsMinSizeRel += " "; extraLinkOptionsMinSizeRel += targetLinkFlags; } if(const char* targetLinkFlags = - target.GetProperty("LINK_FLAGS_RELWITHDEBINFO")) + target->GetProperty("LINK_FLAGS_RELWITHDEBINFO")) { extraLinkOptionsRelWithDebInfo += " "; extraLinkOptionsRelWithDebInfo += targetLinkFlags; } - cmGeneratorTarget* gt = - this->GlobalGenerator->GetGeneratorTarget(&target); - // Get standard libraries for this language. if(targetBuilds) { // Get the language to use for linking. std::vector<std::string> configs; - target.GetMakefile()->GetConfigurations(configs); + target->Target->GetMakefile()->GetConfigurations(configs); std::vector<std::string>::const_iterator it = configs.begin(); - const std::string& linkLanguage = gt->GetLinkerLanguage(*it); + const std::string& linkLanguage = target->GetLinkerLanguage(*it); for ( ; it != configs.end(); ++it) { - const std::string& configLinkLanguage = gt->GetLinkerLanguage(*it); + const std::string& configLinkLanguage = target->GetLinkerLanguage(*it); if (configLinkLanguage != linkLanguage) { cmSystemTools::Error ("Linker language must not vary by configuration for target: ", - target.GetName().c_str()); + target->GetName().c_str()); } } if(linkLanguage.empty()) { cmSystemTools::Error ("CMake can not determine linker language for target: ", - target.GetName().c_str()); + target->GetName().c_str()); return; } @@ -1307,13 +1303,13 @@ void cmLocalVisualStudio6Generator // Compute version number information. std::string targetVersionFlag; - if(target.GetType() == cmTarget::EXECUTABLE || - target.GetType() == cmTarget::SHARED_LIBRARY || - target.GetType() == cmTarget::MODULE_LIBRARY) + if(target->GetType() == cmState::EXECUTABLE || + target->GetType() == cmState::SHARED_LIBRARY || + target->GetType() == cmState::MODULE_LIBRARY) { int major; int minor; - target.GetTargetVersion(major, minor); + target->GetTargetVersion(major, minor); std::ostringstream targetVersionStream; targetVersionStream << "/version:" << major << "." << minor; targetVersionFlag = targetVersionStream.str(); @@ -1326,20 +1322,20 @@ void cmLocalVisualStudio6Generator std::string outputNameRelease = outputName; std::string outputNameMinSizeRel = outputName; std::string outputNameRelWithDebInfo = outputName; - if(target.GetType() == cmTarget::EXECUTABLE || - target.GetType() == cmTarget::STATIC_LIBRARY || - target.GetType() == cmTarget::SHARED_LIBRARY || - target.GetType() == cmTarget::MODULE_LIBRARY) + if(target->GetType() == cmState::EXECUTABLE || + target->GetType() == cmState::STATIC_LIBRARY || + target->GetType() == cmState::SHARED_LIBRARY || + target->GetType() == cmState::MODULE_LIBRARY) { - outputName = gt->GetFullName(); - outputNameDebug = gt->GetFullName("Debug"); - outputNameRelease = gt->GetFullName("Release"); - outputNameMinSizeRel = gt->GetFullName("MinSizeRel"); - outputNameRelWithDebInfo = gt->GetFullName("RelWithDebInfo"); + outputName = target->GetFullName(); + outputNameDebug = target->GetFullName("Debug"); + outputNameRelease = target->GetFullName("Release"); + outputNameMinSizeRel = target->GetFullName("MinSizeRel"); + outputNameRelWithDebInfo = target->GetFullName("RelWithDebInfo"); } - else if(target.GetType() == cmTarget::OBJECT_LIBRARY) + else if(target->GetType() == cmState::OBJECT_LIBRARY) { - outputName = target.GetName(); + outputName = target->GetName(); outputName += ".lib"; outputNameDebug = outputName; outputNameRelease = outputName; @@ -1353,30 +1349,30 @@ void cmLocalVisualStudio6Generator std::string outputDirRelease; std::string outputDirMinSizeRel; std::string outputDirRelWithDebInfo; - if(target.GetType() == cmTarget::EXECUTABLE || - target.GetType() == cmTarget::STATIC_LIBRARY || - target.GetType() == cmTarget::SHARED_LIBRARY || - target.GetType() == cmTarget::MODULE_LIBRARY) + if(target->GetType() == cmState::EXECUTABLE || + target->GetType() == cmState::STATIC_LIBRARY || + target->GetType() == cmState::SHARED_LIBRARY || + target->GetType() == cmState::MODULE_LIBRARY) { #ifdef CM_USE_OLD_VS6 outputDirOld = removeQuotes(this->ConvertToOutputFormat - (target.GetDirectory().c_str(), SHELL)); + (target->GetDirectory().c_str(), SHELL)); #endif outputDirDebug = removeQuotes(this->ConvertToOutputFormat( - target.GetDirectory("Debug").c_str(), SHELL)); + target->GetDirectory("Debug").c_str(), SHELL)); outputDirRelease = removeQuotes(this->ConvertToOutputFormat( - target.GetDirectory("Release").c_str(), SHELL)); + target->GetDirectory("Release").c_str(), SHELL)); outputDirMinSizeRel = removeQuotes(this->ConvertToOutputFormat( - target.GetDirectory("MinSizeRel").c_str(), SHELL)); + target->GetDirectory("MinSizeRel").c_str(), SHELL)); outputDirRelWithDebInfo = removeQuotes(this->ConvertToOutputFormat( - target.GetDirectory("RelWithDebInfo").c_str(), SHELL)); + target->GetDirectory("RelWithDebInfo").c_str(), SHELL)); } - else if(target.GetType() == cmTarget::OBJECT_LIBRARY) + else if(target->GetType() == cmState::OBJECT_LIBRARY) { std::string outputDir = cmake::GetCMakeFilesDirectoryPostSlash(); outputDirDebug = outputDir + "Debug"; @@ -1390,9 +1386,9 @@ void cmLocalVisualStudio6Generator std::string optionsRelease; std::string optionsMinSizeRel; std::string optionsRelWithDebInfo; - if(target.GetType() == cmTarget::EXECUTABLE || - target.GetType() == cmTarget::SHARED_LIBRARY || - target.GetType() == cmTarget::MODULE_LIBRARY) + if(target->GetType() == cmState::EXECUTABLE || + target->GetType() == cmState::SHARED_LIBRARY || + target->GetType() == cmState::MODULE_LIBRARY) { extraLinkOptionsDebug = extraLinkOptions + " " + extraLinkOptionsDebug; @@ -1418,24 +1414,24 @@ void cmLocalVisualStudio6Generator std::string targetImplibFlagRelease; std::string targetImplibFlagMinSizeRel; std::string targetImplibFlagRelWithDebInfo; - if(target.GetType() == cmTarget::SHARED_LIBRARY || - target.GetType() == cmTarget::MODULE_LIBRARY || - target.GetType() == cmTarget::EXECUTABLE) + if(target->GetType() == cmState::SHARED_LIBRARY || + target->GetType() == cmState::MODULE_LIBRARY || + target->GetType() == cmState::EXECUTABLE) { - std::string fullPathImpDebug = target.GetDirectory("Debug", true); - std::string fullPathImpRelease = target.GetDirectory("Release", true); + std::string fullPathImpDebug = target->GetDirectory("Debug", true); + std::string fullPathImpRelease = target->GetDirectory("Release", true); std::string fullPathImpMinSizeRel = - target.GetDirectory("MinSizeRel", true); + target->GetDirectory("MinSizeRel", true); std::string fullPathImpRelWithDebInfo = - target.GetDirectory("RelWithDebInfo", true); + target->GetDirectory("RelWithDebInfo", true); fullPathImpDebug += "/"; fullPathImpRelease += "/"; fullPathImpMinSizeRel += "/"; fullPathImpRelWithDebInfo += "/"; - fullPathImpDebug += gt->GetFullName("Debug", true); - fullPathImpRelease += gt->GetFullName("Release", true); - fullPathImpMinSizeRel += gt->GetFullName("MinSizeRel", true); - fullPathImpRelWithDebInfo += gt->GetFullName("RelWithDebInfo", true); + fullPathImpDebug += target->GetFullName("Debug", true); + fullPathImpRelease += target->GetFullName("Release", true); + fullPathImpMinSizeRel += target->GetFullName("MinSizeRel", true); + fullPathImpRelWithDebInfo += target->GetFullName("RelWithDebInfo", true); targetImplibFlagDebug = "/implib:"; targetImplibFlagRelease = "/implib:"; @@ -1488,7 +1484,7 @@ void cmLocalVisualStudio6Generator std::string staticLibOptionsRelease; std::string staticLibOptionsMinSizeRel; std::string staticLibOptionsRelWithDebInfo; - if(target.GetType() == cmTarget::STATIC_LIBRARY ) + if(target->GetType() == cmState::STATIC_LIBRARY ) { const char *libflagsGlobal = this->Makefile->GetSafeDefinition("CMAKE_STATIC_LINKER_FLAGS"); @@ -1507,7 +1503,7 @@ void cmLocalVisualStudio6Generator this->AppendFlags(staticLibOptionsRelWithDebInfo, this->Makefile-> GetSafeDefinition("CMAKE_STATIC_LINKER_FLAGS_RELWITHDEBINFO")); - const char *libflags = target.GetProperty("STATIC_LIBRARY_FLAGS"); + const char *libflags = target->GetProperty("STATIC_LIBRARY_FLAGS"); this->AppendFlags(staticLibOptions, libflags); this->AppendFlags(staticLibOptionsDebug, libflags); this->AppendFlags(staticLibOptionsRelease, libflags); @@ -1515,13 +1511,13 @@ void cmLocalVisualStudio6Generator this->AppendFlags(staticLibOptionsRelWithDebInfo, libflags); this->AppendFlags(staticLibOptionsDebug, - target.GetProperty("STATIC_LIBRARY_FLAGS_DEBUG")); + target->GetProperty("STATIC_LIBRARY_FLAGS_DEBUG")); this->AppendFlags(staticLibOptionsRelease, - target.GetProperty("STATIC_LIBRARY_FLAGS_RELEASE")); + target->GetProperty("STATIC_LIBRARY_FLAGS_RELEASE")); this->AppendFlags(staticLibOptionsMinSizeRel, - target.GetProperty("STATIC_LIBRARY_FLAGS_MINSIZEREL")); + target->GetProperty("STATIC_LIBRARY_FLAGS_MINSIZEREL")); this->AppendFlags(staticLibOptionsRelWithDebInfo, - target.GetProperty("STATIC_LIBRARY_FLAGS_RELWITHDEBINFO")); + target->GetProperty("STATIC_LIBRARY_FLAGS_RELWITHDEBINFO")); std::string objects; this->OutputObjects(target, "LIB", objects); @@ -1537,7 +1533,7 @@ void cmLocalVisualStudio6Generator // Add the export symbol definition for shared library objects. std::string exportSymbol; - if(const char* exportMacro = target.GetExportMacro()) + if(const char* exportMacro = target->GetExportMacro()) { exportSymbol = exportMacro; } @@ -1561,8 +1557,8 @@ void cmLocalVisualStudio6Generator libnameExports.c_str()); cmSystemTools::ReplaceString(line, "CMAKE_MFC_FLAG", mfcFlag); - if(target.GetType() == cmTarget::STATIC_LIBRARY || - target.GetType() == cmTarget::OBJECT_LIBRARY) + if(target->GetType() == cmState::STATIC_LIBRARY || + target->GetType() == cmState::OBJECT_LIBRARY) { cmSystemTools::ReplaceString(line, "CM_STATIC_LIB_ARGS_DEBUG", staticLibOptionsDebug.c_str()); @@ -1668,7 +1664,7 @@ void cmLocalVisualStudio6Generator (exePath.c_str(), SHELL)).c_str()); #endif - if(targetBuilds || target.GetType() == cmTarget::OBJECT_LIBRARY) + if(targetBuilds || target->GetType() == cmState::OBJECT_LIBRARY) { cmSystemTools::ReplaceString(line, "OUTPUT_DIRECTORY_DEBUG", outputDirDebug.c_str()); @@ -1692,8 +1688,8 @@ void cmLocalVisualStudio6Generator = this->Makefile->GetDefinition("CMAKE_DEBUG_POSTFIX"); cmSystemTools::ReplaceString(line, "DEBUG_POSTFIX", debugPostfix?debugPostfix:""); - if(target.GetType() >= cmTarget::EXECUTABLE && - target.GetType() <= cmTarget::OBJECT_LIBRARY) + if(target->GetType() >= cmState::EXECUTABLE && + target->GetType() <= cmState::OBJECT_LIBRARY) { // store flags for each configuration std::string flags = " "; @@ -1702,24 +1698,24 @@ void cmLocalVisualStudio6Generator std::string flagsDebug = " "; std::string flagsRelWithDebInfo = " "; std::vector<std::string> configs; - target.GetMakefile()->GetConfigurations(configs); + target->Target->GetMakefile()->GetConfigurations(configs); std::vector<std::string>::const_iterator it = configs.begin(); - const std::string& linkLanguage = gt->GetLinkerLanguage(*it); + const std::string& linkLanguage = target->GetLinkerLanguage(*it); for ( ; it != configs.end(); ++it) { - const std::string& configLinkLanguage = gt->GetLinkerLanguage(*it); + const std::string& configLinkLanguage = target->GetLinkerLanguage(*it); if (configLinkLanguage != linkLanguage) { cmSystemTools::Error ("Linker language must not vary by configuration for target: ", - target.GetName().c_str()); + target->GetName().c_str()); } } if(linkLanguage.empty()) { cmSystemTools::Error ("CMake can not determine linker language for target: ", - target.GetName().c_str()); + target->GetName().c_str()); return; } // if CXX is on and the target contains cxx code then add the cxx flags @@ -1744,12 +1740,12 @@ void cmLocalVisualStudio6Generator flagsRelWithDebInfo = this->Makefile->GetSafeDefinition(flagVar.c_str()); flagsRelWithDebInfo += " -DCMAKE_INTDIR=\\\"RelWithDebInfo\\\" "; - this->AddCompileOptions(flags, &target, linkLanguage, ""); - this->AddCompileOptions(flagsDebug, &target, linkLanguage, "Debug"); - this->AddCompileOptions(flagsRelease, &target, linkLanguage, "Release"); - this->AddCompileOptions(flagsMinSizeRel, &target, linkLanguage, + this->AddCompileOptions(flags, target, linkLanguage, ""); + this->AddCompileOptions(flagsDebug, target, linkLanguage, "Debug"); + this->AddCompileOptions(flagsRelease, target, linkLanguage, "Release"); + this->AddCompileOptions(flagsMinSizeRel, target, linkLanguage, "MinSizeRel"); - this->AddCompileOptions(flagsRelWithDebInfo, &target, linkLanguage, + this->AddCompileOptions(flagsRelWithDebInfo, target, linkLanguage, "RelWithDebInfo"); // if _UNICODE and _SBCS are not found, then add -D_MBCS @@ -1769,14 +1765,14 @@ void cmLocalVisualStudio6Generator std::set<std::string> minsizeDefinesSet; std::set<std::string> debugrelDefinesSet; - this->AddCompileDefinitions(definesSet, &target, "", linkLanguage); - this->AddCompileDefinitions(debugDefinesSet, &target, + this->AddCompileDefinitions(definesSet, target, "", linkLanguage); + this->AddCompileDefinitions(debugDefinesSet, target, "DEBUG", linkLanguage); - this->AddCompileDefinitions(releaseDefinesSet, &target, + this->AddCompileDefinitions(releaseDefinesSet, target, "RELEASE", linkLanguage); - this->AddCompileDefinitions(minsizeDefinesSet, &target, + this->AddCompileDefinitions(minsizeDefinesSet, target, "MINSIZEREL", linkLanguage); - this->AddCompileDefinitions(debugrelDefinesSet, &target, + this->AddCompileDefinitions(debugrelDefinesSet, target, "RELWITHDEBINFO", linkLanguage); std::string defines = " "; @@ -1844,15 +1840,13 @@ void cmLocalVisualStudio6Generator::WriteDSPFooter(std::ostream& fout) //---------------------------------------------------------------------------- void cmLocalVisualStudio6Generator -::ComputeLinkOptions(cmTarget& target, +::ComputeLinkOptions(cmGeneratorTarget *target, const std::string& configName, const std::string extraOptions, std::string& options) { - cmGeneratorTarget* gt = - this->GlobalGenerator->GetGeneratorTarget(&target); // Compute the link information for this configuration. - cmComputeLinkInformation* pcli = gt->GetLinkInformation(configName); + cmComputeLinkInformation* pcli = target->GetLinkInformation(configName); if(!pcli) { return; @@ -1893,7 +1887,7 @@ void cmLocalVisualStudio6Generator this->ConvertToOutputFormat(l->Value.c_str(), SHELL); } else if (!l->Target - || l->Target->GetType() != cmTarget::INTERFACE_LIBRARY) + || l->Target->GetType() != cmState::INTERFACE_LIBRARY) { options += l->Value; } @@ -1911,15 +1905,13 @@ void cmLocalVisualStudio6Generator //---------------------------------------------------------------------------- void cmLocalVisualStudio6Generator -::OutputObjects(cmTarget& target, const char* tool, +::OutputObjects(cmGeneratorTarget* target, const char* tool, std::string& options) { // VS 6 does not support per-config source locations so we // list object library content on the link line instead. - cmGeneratorTarget* gt = - this->GlobalGenerator->GetGeneratorTarget(&target); std::vector<std::string> objs; - gt->UseObjectLibraries(objs, ""); + target->UseObjectLibraries(objs, ""); for(std::vector<std::string>::const_iterator oi = objs.begin(); oi != objs.end(); ++oi) { @@ -1933,7 +1925,7 @@ void cmLocalVisualStudio6Generator std::string cmLocalVisualStudio6Generator -::GetTargetDirectory(cmTarget const&) const +::GetTargetDirectory(cmGeneratorTarget const*) const { // No per-target directory for this generator (yet). return ""; @@ -1942,7 +1934,7 @@ cmLocalVisualStudio6Generator //---------------------------------------------------------------------------- std::string cmLocalVisualStudio6Generator -::ComputeLongestObjectDirectory(cmTarget&) const +::ComputeLongestObjectDirectory(cmGeneratorTarget const*) const { // Compute the maximum length configuration name. std::string config_max; @@ -1962,7 +1954,7 @@ cmLocalVisualStudio6Generator // files directory for any configuration. This is used to construct // object file names that do not produce paths that are too long. std::string dir_max; - dir_max += this->Makefile->GetCurrentBinaryDirectory(); + dir_max += this->GetCurrentBinaryDirectory(); dir_max += "/"; dir_max += config_max; dir_max += "/"; diff --git a/Source/cmLocalVisualStudio6Generator.h b/Source/cmLocalVisualStudio6Generator.h index 828d252..dab32a5 100644 --- a/Source/cmLocalVisualStudio6Generator.h +++ b/Source/cmLocalVisualStudio6Generator.h @@ -14,7 +14,6 @@ #include "cmLocalVisualStudioGenerator.h" -class cmTarget; class cmSourceFile; class cmSourceGroup; class cmCustomCommand; @@ -47,49 +46,52 @@ public: /** * Specify the type of the build: static, dll, or executable. */ - void SetBuildType(BuildType, const std::string& libName, cmTarget&); + void SetBuildType(BuildType, const std::string& libName, cmGeneratorTarget*); - virtual std::string GetTargetDirectory(cmTarget const& target) const; - virtual std::string ComputeLongestObjectDirectory(cmTarget&) const; + virtual + std::string GetTargetDirectory(cmGeneratorTarget const* target) const; + virtual std::string + ComputeLongestObjectDirectory(cmGeneratorTarget const*) const; private: std::string DSPHeaderTemplate; std::string DSPFooterTemplate; - void CreateSingleDSP(const std::string& lname, cmTarget &tgt); + void CreateSingleDSP(const std::string& lname, cmGeneratorTarget* tgt); void WriteDSPFile(std::ostream& fout, const std::string& libName, - cmTarget &tgt); + cmGeneratorTarget* tgt); void WriteDSPBeginGroup(std::ostream& fout, const char* group, const char* filter); void WriteDSPEndGroup(std::ostream& fout); void WriteDSPHeader(std::ostream& fout, const std::string& libName, - cmTarget &tgt, std::vector<cmSourceGroup> &sgs); + cmGeneratorTarget* tgt, std::vector<cmSourceGroup> &sgs); void WriteDSPFooter(std::ostream& fout); - void AddDSPBuildRule(cmTarget& tgt); + void AddDSPBuildRule(cmGeneratorTarget* tgt); void WriteCustomRule(std::ostream& fout, const char* source, const cmCustomCommand& command, const char* flags); - void AddUtilityCommandHack(cmTarget& target, int count, + void AddUtilityCommandHack(cmGeneratorTarget* target, int count, std::vector<std::string>& depends, const cmCustomCommand& origCommand); - void WriteGroup(const cmSourceGroup *sg, cmTarget& target, + void WriteGroup(const cmSourceGroup *sg, cmGeneratorTarget* target, std::ostream &fout, const std::string& libName); class EventWriter; friend class EventWriter; cmsys::auto_ptr<cmCustomCommand> - MaybeCreateOutputDir(cmTarget& target, const std::string& config); - std::string CreateTargetRules(cmTarget &target, + MaybeCreateOutputDir(cmGeneratorTarget *target, const std::string& config); + std::string CreateTargetRules(cmGeneratorTarget* target, const std::string& configName, const std::string& libName); - void ComputeLinkOptions(cmTarget& target, const std::string& configName, + void ComputeLinkOptions(cmGeneratorTarget* target, + const std::string& configName, const std::string extraOptions, std::string& options); - void OutputObjects(cmTarget& target, const char* tool, + void OutputObjects(cmGeneratorTarget* target, const char* tool, std::string& options); - std::string GetTargetIncludeOptions(cmTarget &target, + std::string GetTargetIncludeOptions(cmGeneratorTarget* target, const std::string& config); std::vector<std::string> Configurations; diff --git a/Source/cmLocalVisualStudio7Generator.cxx b/Source/cmLocalVisualStudio7Generator.cxx index a4bce8a..ae6a24e 100644 --- a/Source/cmLocalVisualStudio7Generator.cxx +++ b/Source/cmLocalVisualStudio7Generator.cxx @@ -34,7 +34,8 @@ public: LocalGenerator(e) {} typedef cmComputeLinkInformation::ItemVector ItemVector; void OutputLibraries(std::ostream& fout, ItemVector const& libs); - void OutputObjects(std::ostream& fout, cmTarget* t, const char* isep = 0); + void OutputObjects(std::ostream& fout, cmGeneratorTarget* t, + const char* isep = 0); private: cmLocalVisualStudio7Generator* LocalGenerator; }; @@ -67,19 +68,19 @@ cmLocalVisualStudio7Generator::~cmLocalVisualStudio7Generator() void cmLocalVisualStudio7Generator::AddHelperCommands() { // Now create GUIDs for targets - cmTargets &tgts = this->Makefile->GetTargets(); - - for(cmTargets::iterator l = tgts.begin(); l != tgts.end(); l++) + std::vector<cmGeneratorTarget*> tgts = this->GetGeneratorTargets(); + for(std::vector<cmGeneratorTarget*>::iterator l = tgts.begin(); + l != tgts.end(); ++l) { - if(l->second.GetType() == cmTarget::INTERFACE_LIBRARY) + if((*l)->GetType() == cmState::INTERFACE_LIBRARY) { continue; } - const char* path = l->second.GetProperty("EXTERNAL_MSPROJECT"); + const char* path = (*l)->GetProperty("EXTERNAL_MSPROJECT"); if(path) { this->ReadAndStoreExternalGUID( - l->second.GetName().c_str(), path); + (*l)->GetName().c_str(), path); } } @@ -95,7 +96,6 @@ void cmLocalVisualStudio7Generator::Generate() void cmLocalVisualStudio7Generator::AddCMakeListsRules() { - cmTargets &tgts = this->Makefile->GetTargets(); // Create the regeneration custom rule. if(!this->Makefile->IsOn("CMAKE_SUPPRESS_REGENERATION")) { @@ -104,15 +104,17 @@ void cmLocalVisualStudio7Generator::AddCMakeListsRules() if(cmSourceFile* sf = this->CreateVCProjBuildRule()) { // Add the rule to targets that need it. - for(cmTargets::iterator l = tgts.begin(); l != tgts.end(); ++l) + std::vector<cmGeneratorTarget*> tgts = this->GetGeneratorTargets(); + for(std::vector<cmGeneratorTarget*>::iterator l = tgts.begin(); + l != tgts.end(); ++l) { - if (l->second.GetType() == cmTarget::GLOBAL_TARGET) + if ((*l)->GetType() == cmState::GLOBAL_TARGET) { continue; } - if(l->first != CMAKE_CHECK_BUILD_SYSTEM_TARGET) + if((*l)->GetName() != CMAKE_CHECK_BUILD_SYSTEM_TARGET) { - l->second.AddSource(sf->GetFullPath()); + (*l)->AddSource(sf->GetFullPath()); } } } @@ -124,12 +126,11 @@ void cmLocalVisualStudio7Generator::FixGlobalTargets() // Visual Studio .NET 2003 Service Pack 1 will not run post-build // commands for targets in which no sources are built. Add dummy // rules to force these targets to build. - cmTargets &tgts = this->Makefile->GetTargets(); - for(cmTargets::iterator l = tgts.begin(); + std::vector<cmGeneratorTarget*> tgts = this->GetGeneratorTargets(); + for(std::vector<cmGeneratorTarget*>::iterator l = tgts.begin(); l != tgts.end(); l++) { - cmTarget& tgt = l->second; - if(tgt.GetType() == cmTarget::GLOBAL_TARGET) + if((*l)->GetType() == cmState::GLOBAL_TARGET) { std::vector<std::string> no_depends; cmCustomCommandLine force_command; @@ -138,17 +139,17 @@ void cmLocalVisualStudio7Generator::FixGlobalTargets() cmCustomCommandLines force_commands; force_commands.push_back(force_command); std::string no_main_dependency = ""; - std::string force = this->Makefile->GetCurrentBinaryDirectory(); + std::string force = this->GetCurrentBinaryDirectory(); force += cmake::GetCMakeFilesDirectory(); force += "/"; - force += tgt.GetName(); + force += (*l)->GetName(); force += "_force"; if(cmSourceFile* file = this->Makefile->AddCustomCommandToOutput( force.c_str(), no_depends, no_main_dependency, force_commands, " ", 0, true)) { - tgt.AddSource(file->GetFullPath()); + (*l)->AddSource(file->GetFullPath()); } } } @@ -160,33 +161,33 @@ void cmLocalVisualStudio7Generator::FixGlobalTargets() void cmLocalVisualStudio7Generator::WriteProjectFiles() { // If not an in source build, then create the output directory - if(strcmp(this->Makefile->GetCurrentBinaryDirectory(), - this->Makefile->GetHomeDirectory()) != 0) + if(strcmp(this->GetCurrentBinaryDirectory(), + this->GetSourceDirectory()) != 0) { if(!cmSystemTools::MakeDirectory - (this->Makefile->GetCurrentBinaryDirectory())) + (this->GetCurrentBinaryDirectory())) { cmSystemTools::Error("Error creating directory ", - this->Makefile->GetCurrentBinaryDirectory()); + this->GetCurrentBinaryDirectory()); } } // Get the set of targets in this directory. - cmTargets &tgts = this->Makefile->GetTargets(); + std::vector<cmGeneratorTarget*> tgts = this->GetGeneratorTargets(); // Create the project file for each target. - for(cmTargets::iterator l = tgts.begin(); + for(std::vector<cmGeneratorTarget*>::iterator l = tgts.begin(); l != tgts.end(); l++) { - if(l->second.GetType() == cmTarget::INTERFACE_LIBRARY) + if((*l)->GetType() == cmState::INTERFACE_LIBRARY) { continue; } // INCLUDE_EXTERNAL_MSPROJECT command only affects the workspace // so don't build a projectfile for it - if(!l->second.GetProperty("EXTERNAL_MSPROJECT")) + if(!(*l)->GetProperty("EXTERNAL_MSPROJECT")) { - this->CreateSingleVCProj(l->first.c_str(),l->second); + this->CreateSingleVCProj((*l)->GetName().c_str(), *l); } } } @@ -196,7 +197,7 @@ void cmLocalVisualStudio7Generator::WriteStampFiles() { // Touch a timestamp file used to determine when the project file is // out of date. - std::string stampName = this->Makefile->GetCurrentBinaryDirectory(); + std::string stampName = this->GetCurrentBinaryDirectory(); stampName += cmake::GetCMakeFilesDirectory(); cmSystemTools::MakeDirectory(stampName.c_str()); stampName += "/"; @@ -224,7 +225,7 @@ void cmLocalVisualStudio7Generator::WriteStampFiles() //---------------------------------------------------------------------------- void cmLocalVisualStudio7Generator -::CreateSingleVCProj(const std::string& lname, cmTarget &target) +::CreateSingleVCProj(const std::string& lname, cmGeneratorTarget *target) { cmGlobalVisualStudioGenerator* gg = static_cast<cmGlobalVisualStudioGenerator*>(this->GlobalGenerator); @@ -240,10 +241,10 @@ void cmLocalVisualStudio7Generator } // add to the list of projects - target.SetProperty("GENERATOR_FILE_NAME",lname.c_str()); + target->Target->SetProperty("GENERATOR_FILE_NAME",lname.c_str()); // create the dsp.cmake file std::string fname; - fname = this->Makefile->GetCurrentBinaryDirectory(); + fname = this->GetCurrentBinaryDirectory(); fname += "/"; fname += lname; if(this->FortranProject) @@ -272,13 +273,13 @@ void cmLocalVisualStudio7Generator //---------------------------------------------------------------------------- cmSourceFile* cmLocalVisualStudio7Generator::CreateVCProjBuildRule() { - std::string stampName = this->Makefile->GetCurrentBinaryDirectory(); + std::string stampName = this->GetCurrentBinaryDirectory(); stampName += "/"; stampName += cmake::GetCMakeFilesDirectoryPostSlash(); stampName += "generate.stamp"; cmCustomCommandLine commandLine; commandLine.push_back(cmSystemTools::GetCMakeCommand()); - std::string makefileIn = this->Makefile->GetCurrentSourceDirectory(); + std::string makefileIn = this->GetCurrentSourceDirectory(); makefileIn += "/"; makefileIn += "CMakeLists.txt"; makefileIn = cmSystemTools::CollapseFullPath(makefileIn.c_str()); @@ -290,10 +291,10 @@ cmSourceFile* cmLocalVisualStudio7Generator::CreateVCProjBuildRule() comment += makefileIn; std::string args; args = "-H"; - args += this->Makefile->GetHomeDirectory(); + args += this->GetSourceDirectory(); commandLine.push_back(args); args = "-B"; - args += this->Makefile->GetHomeOutputDirectory(); + args += this->GetBinaryDirectory(); commandLine.push_back(args); commandLine.push_back("--check-stamp-file"); std::string stampFilename = this->Convert(stampName.c_str(), FULL, @@ -323,8 +324,9 @@ cmSourceFile* cmLocalVisualStudio7Generator::CreateVCProjBuildRule() } void cmLocalVisualStudio7Generator::WriteConfigurations( - std::ostream& fout, std::vector<std::string> const& configs, - const std::string& libName, cmTarget &target + std::ostream& fout, + std::vector<std::string> const& configs, + const std::string& libName, cmGeneratorTarget *target ) { fout << "\t<Configurations>\n"; @@ -642,7 +644,7 @@ private: void cmLocalVisualStudio7Generator::WriteConfiguration(std::ostream& fout, const std::string& configName, const std::string& libName, - cmTarget &target) + cmGeneratorTarget *target) { const char* mfcFlag = this->Makefile->GetDefinition("CMAKE_MFC_FLAG"); if(!mfcFlag) @@ -663,27 +665,24 @@ void cmLocalVisualStudio7Generator::WriteConfiguration(std::ostream& fout, const char* projectType = 0; bool targetBuilds = true; - cmGeneratorTarget* gt = - this->GlobalGenerator->GetGeneratorTarget(&target); - - switch(target.GetType()) + switch(target->GetType()) { - case cmTarget::OBJECT_LIBRARY: + case cmState::OBJECT_LIBRARY: targetBuilds = false; // no manifest tool for object library - case cmTarget::STATIC_LIBRARY: + case cmState::STATIC_LIBRARY: projectType = "typeStaticLibrary"; configType = "4"; break; - case cmTarget::SHARED_LIBRARY: - case cmTarget::MODULE_LIBRARY: + case cmState::SHARED_LIBRARY: + case cmState::MODULE_LIBRARY: projectType = "typeDynamicLibrary"; configType = "2"; break; - case cmTarget::EXECUTABLE: + case cmState::EXECUTABLE: configType = "1"; break; - case cmTarget::UTILITY: - case cmTarget::GLOBAL_TARGET: + case cmState::UTILITY: + case cmState::GLOBAL_TARGET: configType = "10"; default: targetBuilds = false; @@ -698,12 +697,12 @@ void cmLocalVisualStudio7Generator::WriteConfiguration(std::ostream& fout, { const std::string& linkLanguage = (this->FortranProject? std::string("Fortran"): - gt->GetLinkerLanguage(configName)); + target->GetLinkerLanguage(configName)); if(linkLanguage.empty()) { cmSystemTools::Error ("CMake can not determine linker language for target: ", - target.GetName().c_str()); + target->GetName().c_str()); return; } if(linkLanguage == "C" || linkLanguage == "CXX" @@ -729,12 +728,12 @@ void cmLocalVisualStudio7Generator::WriteConfiguration(std::ostream& fout, } // Add the target-specific flags. - this->AddCompileOptions(flags, &target, linkLanguage, configName); + this->AddCompileOptions(flags, target, linkLanguage, configName); } if(this->FortranProject) { - switch(this->GetFortranFormat(target.GetProperty("Fortran_FORMAT"))) + switch(this->GetFortranFormat(target->GetProperty("Fortran_FORMAT"))) { case FortranFormatFixed: flags += " -fixed"; break; case FortranFormatFree: flags += " -free"; break; @@ -761,7 +760,7 @@ void cmLocalVisualStudio7Generator::WriteConfiguration(std::ostream& fout, targetOptions.Parse(defineFlags.c_str()); targetOptions.ParseFinish(); std::vector<std::string> targetDefines; - gt->GetCompileDefinitions(targetDefines, configName, "CXX"); + target->GetCompileDefinitions(targetDefines, configName, "CXX"); targetOptions.AddDefines(targetDefines); targetOptions.SetVerboseMakefile( this->Makefile->IsOn("CMAKE_VERBOSE_MAKEFILE")); @@ -773,7 +772,7 @@ void cmLocalVisualStudio7Generator::WriteConfiguration(std::ostream& fout, targetOptions.AddDefine(configDefine); // Add the export symbol definition for shared library objects. - if(const char* exportMacro = target.GetExportMacro()) + if(const char* exportMacro = target->GetExportMacro()) { targetOptions.AddDefine(exportMacro); } @@ -784,11 +783,11 @@ void cmLocalVisualStudio7Generator::WriteConfiguration(std::ostream& fout, intermediateDir += "/"; intermediateDir += configName; - if (target.GetType() < cmTarget::UTILITY) + if (target->GetType() < cmState::UTILITY) { std::string const& outDir = - target.GetType() == cmTarget::OBJECT_LIBRARY? - intermediateDir : target.GetDirectory(configName); + target->GetType() == cmState::OBJECT_LIBRARY? + intermediateDir : target->GetDirectory(configName); fout << "\t\t\tOutputDirectory=\"" << this->ConvertToXMLOutputPathSingle(outDir.c_str()) << "\"\n"; } @@ -803,7 +802,7 @@ void cmLocalVisualStudio7Generator::WriteConfiguration(std::ostream& fout, if (this->FortranProject) { // Intel Fortran >= 15.0 uses TargetName property. - std::string targetNameFull = gt->GetFullName(configName); + std::string targetNameFull = target->GetFullName(configName); std::string targetName = cmSystemTools::GetFilenameWithoutLastExtension(targetNameFull); std::string targetExt = @@ -838,7 +837,7 @@ void cmLocalVisualStudio7Generator::WriteConfiguration(std::ostream& fout, if(this->FortranProject) { const char* target_mod_dir = - target.GetProperty("Fortran_MODULE_DIRECTORY"); + target->GetProperty("Fortran_MODULE_DIRECTORY"); std::string modDir; if(target_mod_dir) { @@ -857,7 +856,7 @@ void cmLocalVisualStudio7Generator::WriteConfiguration(std::ostream& fout, targetOptions.OutputAdditionalOptions(fout, "\t\t\t\t", "\n"); fout << "\t\t\t\tAdditionalIncludeDirectories=\""; std::vector<std::string> includes; - this->GetIncludeDirectories(includes, gt, "C", configName); + this->GetIncludeDirectories(includes, target, "C", configName); std::vector<std::string>::iterator i = includes.begin(); for(;i != includes.end(); ++i) { @@ -878,10 +877,10 @@ void cmLocalVisualStudio7Generator::WriteConfiguration(std::ostream& fout, targetOptions.OutputFlagMap(fout, "\t\t\t\t"); targetOptions.OutputPreprocessorDefinitions(fout, "\t\t\t\t", "\n", "CXX"); fout << "\t\t\t\tObjectFile=\"$(IntDir)\\\"\n"; - if(target.GetType() <= cmTarget::OBJECT_LIBRARY) + if(target->GetType() <= cmState::OBJECT_LIBRARY) { // Specify the compiler program database file if configured. - std::string pdb = gt->GetCompilePDBPath(configName); + std::string pdb = target->GetCompilePDBPath(configName); if(!pdb.empty()) { fout << "\t\t\t\tProgramDataBaseFileName=\"" @@ -985,7 +984,7 @@ void cmLocalVisualStudio7Generator::WriteConfiguration(std::ostream& fout, "\t\t\t\tName=\"" << manifestTool << "\""; std::vector<cmSourceFile const*> manifest_srcs; - gt->GetManifests(manifest_srcs, configName); + target->GetManifests(manifest_srcs, configName); if (!manifest_srcs.empty()) { fout << "\n\t\t\t\tAdditionalManifestFiles=\""; @@ -1000,7 +999,7 @@ void cmLocalVisualStudio7Generator::WriteConfiguration(std::ostream& fout, // Check if we need the FAT32 workaround. // Check the filesystem type where the target will be written. - if (cmLVS6G_IsFAT(target.GetDirectory(configName).c_str())) + if (cmLVS6G_IsFAT(target->GetDirectory(configName).c_str())) { // Add a flag telling the manifest tool to use a workaround // for FAT32 file systems, which can cause an empty manifest @@ -1034,28 +1033,28 @@ cmLocalVisualStudio7Generator } void cmLocalVisualStudio7Generator::OutputBuildTool(std::ostream& fout, - const std::string& configName, cmTarget &target, + const std::string& configName, cmGeneratorTarget* target, const Options& targetOptions) { cmGlobalVisualStudio7Generator* gg = static_cast<cmGlobalVisualStudio7Generator*>(this->GlobalGenerator); std::string temp; std::string extraLinkOptions; - if(target.GetType() == cmTarget::EXECUTABLE) + if(target->GetType() == cmState::EXECUTABLE) { extraLinkOptions = this->Makefile->GetRequiredDefinition("CMAKE_EXE_LINKER_FLAGS") + std::string(" ") + GetBuildTypeLinkerFlags("CMAKE_EXE_LINKER_FLAGS", configName); } - if(target.GetType() == cmTarget::SHARED_LIBRARY) + if(target->GetType() == cmState::SHARED_LIBRARY) { extraLinkOptions = this->Makefile->GetRequiredDefinition("CMAKE_SHARED_LINKER_FLAGS") + std::string(" ") + GetBuildTypeLinkerFlags("CMAKE_SHARED_LINKER_FLAGS", configName); } - if(target.GetType() == cmTarget::MODULE_LIBRARY) + if(target->GetType() == cmState::MODULE_LIBRARY) { extraLinkOptions = this->Makefile->GetRequiredDefinition("CMAKE_MODULE_LINKER_FLAGS") @@ -1063,7 +1062,7 @@ void cmLocalVisualStudio7Generator::OutputBuildTool(std::ostream& fout, + GetBuildTypeLinkerFlags("CMAKE_MODULE_LINKER_FLAGS", configName); } - const char* targetLinkFlags = target.GetProperty("LINK_FLAGS"); + const char* targetLinkFlags = target->GetProperty("LINK_FLAGS"); if(targetLinkFlags) { extraLinkOptions += " "; @@ -1072,7 +1071,7 @@ void cmLocalVisualStudio7Generator::OutputBuildTool(std::ostream& fout, std::string configTypeUpper = cmSystemTools::UpperCase(configName); std::string linkFlagsConfig = "LINK_FLAGS_"; linkFlagsConfig += configTypeUpper; - targetLinkFlags = target.GetProperty(linkFlagsConfig.c_str()); + targetLinkFlags = target->GetProperty(linkFlagsConfig.c_str()); if(targetLinkFlags) { extraLinkOptions += " "; @@ -1092,28 +1091,26 @@ void cmLocalVisualStudio7Generator::OutputBuildTool(std::ostream& fout, this->ConvertToOutputFormat(this->ModuleDefinitionFile, SHELL); linkOptions.AddFlag("ModuleDefinitionFile", defFile.c_str()); } - cmGeneratorTarget* gt = - this->GlobalGenerator->GetGeneratorTarget(&target); - if (target.GetType() == cmTarget::SHARED_LIBRARY && + if (target->GetType() == cmState::SHARED_LIBRARY && this->Makefile->IsOn("CMAKE_SUPPORT_WINDOWS_EXPORT_ALL_SYMBOLS")) { - if (target.GetPropertyAsBool("WINDOWS_EXPORT_ALL_SYMBOLS")) + if (target->GetPropertyAsBool("WINDOWS_EXPORT_ALL_SYMBOLS")) { linkOptions.AddFlag("ModuleDefinitionFile", "$(IntDir)/exportall.def"); } } - switch(target.GetType()) + switch(target->GetType()) { - case cmTarget::UNKNOWN_LIBRARY: + case cmState::UNKNOWN_LIBRARY: break; - case cmTarget::OBJECT_LIBRARY: + case cmState::OBJECT_LIBRARY: { std::string libpath = this->GetTargetDirectory(target); libpath += "/"; libpath += configName; libpath += "/"; - libpath += target.GetName(); + libpath += target->GetName(); libpath += ".lib"; const char* tool = this->FortranProject? "VFLibrarianTool":"VCLibrarianTool"; @@ -1123,10 +1120,10 @@ void cmLocalVisualStudio7Generator::OutputBuildTool(std::ostream& fout, << this->ConvertToXMLOutputPathSingle(libpath.c_str()) << "\"/>\n"; break; } - case cmTarget::STATIC_LIBRARY: + case cmState::STATIC_LIBRARY: { - std::string targetNameFull = gt->GetFullName(configName); - std::string libpath = target.GetDirectory(configName); + std::string targetNameFull = target->GetFullName(configName); + std::string libpath = target->GetDirectory(configName); libpath += "/"; libpath += targetNameFull; const char* tool = "VCLibrarianTool"; @@ -1141,14 +1138,14 @@ void cmLocalVisualStudio7Generator::OutputBuildTool(std::ostream& fout, || this->FortranProject) { std::ostringstream libdeps; - this->Internal->OutputObjects(libdeps, &target); + this->Internal->OutputObjects(libdeps, target); if(!libdeps.str().empty()) { fout << "\t\t\t\tAdditionalDependencies=\"" << libdeps.str() << "\"\n"; } } std::string libflags; - this->GetStaticLibraryFlags(libflags, configTypeUpper, &target); + this->GetStaticLibraryFlags(libflags, configTypeUpper, target); if(!libflags.empty()) { fout << "\t\t\t\tAdditionalOptions=\"" << libflags << "\"\n"; @@ -1157,19 +1154,19 @@ void cmLocalVisualStudio7Generator::OutputBuildTool(std::ostream& fout, << this->ConvertToXMLOutputPathSingle(libpath.c_str()) << "\"/>\n"; break; } - case cmTarget::SHARED_LIBRARY: - case cmTarget::MODULE_LIBRARY: + case cmState::SHARED_LIBRARY: + case cmState::MODULE_LIBRARY: { std::string targetName; std::string targetNameSO; std::string targetNameFull; std::string targetNameImport; std::string targetNamePDB; - gt->GetLibraryNames(targetName, targetNameSO, targetNameFull, + target->GetLibraryNames(targetName, targetNameSO, targetNameFull, targetNameImport, targetNamePDB, configName); // Compute the link library and directory information. - cmComputeLinkInformation* pcli = gt->GetLinkInformation(configName); + cmComputeLinkInformation* pcli = target->GetLinkInformation(configName); if(!pcli) { return; @@ -1201,12 +1198,12 @@ void cmLocalVisualStudio7Generator::OutputBuildTool(std::ostream& fout, if(this->GetVersion() < cmGlobalVisualStudioGenerator::VS8 || this->FortranProject) { - this->Internal->OutputObjects(fout, &target, " "); + this->Internal->OutputObjects(fout, target, " "); } fout << " "; this->Internal->OutputLibraries(fout, cli.GetItems()); fout << "\"\n"; - temp = target.GetDirectory(configName); + temp = target->GetDirectory(configName); temp += "/"; temp += targetNameFull; fout << "\t\t\t\tOutputFile=\"" @@ -1216,7 +1213,7 @@ void cmLocalVisualStudio7Generator::OutputBuildTool(std::ostream& fout, fout << "\t\t\t\tAdditionalLibraryDirectories=\""; this->OutputLibraryDirectories(fout, cli.GetDirectories()); fout << "\"\n"; - temp = target.GetPDBDirectory(configName); + temp = target->GetPDBDirectory(configName); temp += "/"; temp += targetNamePDB; fout << "\t\t\t\tProgramDatabaseFile=\"" << @@ -1244,7 +1241,7 @@ void cmLocalVisualStudio7Generator::OutputBuildTool(std::ostream& fout, { fout << "\t\t\t\tStackReserveSize=\"" << stackVal << "\"\n"; } - temp = target.GetDirectory(configName, true); + temp = target->GetDirectory(configName, true); temp += "/"; temp += targetNameImport; fout << "\t\t\t\tImportLibrary=\"" @@ -1256,17 +1253,17 @@ void cmLocalVisualStudio7Generator::OutputBuildTool(std::ostream& fout, fout << "/>\n"; } break; - case cmTarget::EXECUTABLE: + case cmState::EXECUTABLE: { std::string targetName; std::string targetNameFull; std::string targetNameImport; std::string targetNamePDB; - gt->GetExecutableNames(targetName, targetNameFull, + target->GetExecutableNames(targetName, targetNameFull, targetNameImport, targetNamePDB, configName); // Compute the link library and directory information. - cmComputeLinkInformation* pcli = gt->GetLinkInformation(configName); + cmComputeLinkInformation* pcli = target->GetLinkInformation(configName); if(!pcli) { return; @@ -1274,7 +1271,7 @@ void cmLocalVisualStudio7Generator::OutputBuildTool(std::ostream& fout, cmComputeLinkInformation& cli = *pcli; std::string linkLanguage = cli.GetLinkLanguage(); - bool isWin32Executable = target.GetPropertyAsBool("WIN32_EXECUTABLE"); + bool isWin32Executable = target->GetPropertyAsBool("WIN32_EXECUTABLE"); // Compute the variable name to lookup standard libraries for this // language. @@ -1300,12 +1297,12 @@ void cmLocalVisualStudio7Generator::OutputBuildTool(std::ostream& fout, if(this->GetVersion() < cmGlobalVisualStudioGenerator::VS8 || this->FortranProject) { - this->Internal->OutputObjects(fout, &target, " "); + this->Internal->OutputObjects(fout, target, " "); } fout << " "; this->Internal->OutputLibraries(fout, cli.GetItems()); fout << "\"\n"; - temp = target.GetDirectory(configName); + temp = target->GetDirectory(configName); temp += "/"; temp += targetNameFull; fout << "\t\t\t\tOutputFile=\"" @@ -1316,7 +1313,7 @@ void cmLocalVisualStudio7Generator::OutputBuildTool(std::ostream& fout, this->OutputLibraryDirectories(fout, cli.GetDirectories()); fout << "\"\n"; std::string path = this->ConvertToXMLOutputPathSingle( - target.GetPDBDirectory(configName).c_str()); + target->GetPDBDirectory(configName).c_str()); fout << "\t\t\t\tProgramDatabaseFile=\"" << path << "/" << targetNamePDB << "\"\n"; @@ -1363,16 +1360,16 @@ void cmLocalVisualStudio7Generator::OutputBuildTool(std::ostream& fout, { fout << "\t\t\t\tStackReserveSize=\"" << stackVal << "\""; } - temp = target.GetDirectory(configName, true); + temp = target->GetDirectory(configName, true); temp += "/"; temp += targetNameImport; fout << "\t\t\t\tImportLibrary=\"" << this->ConvertToXMLOutputPathSingle(temp.c_str()) << "\"/>\n"; break; } - case cmTarget::UTILITY: - case cmTarget::GLOBAL_TARGET: - case cmTarget::INTERFACE_LIBRARY: + case cmState::UTILITY: + case cmState::GLOBAL_TARGET: + case cmState::INTERFACE_LIBRARY: break; } } @@ -1380,11 +1377,11 @@ void cmLocalVisualStudio7Generator::OutputBuildTool(std::ostream& fout, //---------------------------------------------------------------------------- void cmLocalVisualStudio7Generator -::WriteTargetVersionAttribute(std::ostream& fout, cmTarget& target) +::WriteTargetVersionAttribute(std::ostream& fout, cmGeneratorTarget* gt) { int major; int minor; - target.GetTargetVersion(major, minor); + gt->GetTargetVersion(major, minor); fout << "\t\t\t\tVersion=\"" << major << "." << minor << "\"\n"; } @@ -1404,7 +1401,7 @@ cmLocalVisualStudio7GeneratorInternals fout << lg->ConvertToXMLOutputPath(rel.c_str()) << " "; } else if (!l->Target - || l->Target->GetType() != cmTarget::INTERFACE_LIBRARY) + || l->Target->GetType() != cmState::INTERFACE_LIBRARY) { fout << l->Value << " "; } @@ -1414,13 +1411,11 @@ cmLocalVisualStudio7GeneratorInternals //---------------------------------------------------------------------------- void cmLocalVisualStudio7GeneratorInternals -::OutputObjects(std::ostream& fout, cmTarget* t, const char* isep) +::OutputObjects(std::ostream& fout, cmGeneratorTarget* gt, const char* isep) { // VS < 8 does not support per-config source locations so we // list object library content on the link line instead. cmLocalVisualStudio7Generator* lg = this->LocalGenerator; - cmGeneratorTarget* gt = - lg->GetGlobalGenerator()->GetGeneratorTarget(t); std::vector<std::string> objs; gt->UseObjectLibraries(objs, ""); const char* sep = isep? isep : ""; @@ -1477,7 +1472,7 @@ cmLocalVisualStudio7Generator void cmLocalVisualStudio7Generator::WriteVCProjFile(std::ostream& fout, const std::string& libName, - cmTarget &target) + cmGeneratorTarget* target) { std::vector<std::string> configs; this->Makefile->GetConfigurations(configs); @@ -1485,13 +1480,10 @@ void cmLocalVisualStudio7Generator::WriteVCProjFile(std::ostream& fout, // We may be modifying the source groups temporarily, so make a copy. std::vector<cmSourceGroup> sourceGroups = this->Makefile->GetSourceGroups(); - cmGeneratorTarget* gt = - this->GlobalGenerator->GetGeneratorTarget(&target); - // get the classes from the source lists then add them to the groups this->ModuleDefinitionFile = ""; std::vector<cmSourceFile*> classes; - if (!gt->GetConfigCommonSourceFiles(classes)) + if (!target->GetConfigCommonSourceFiles(classes)) { return; } @@ -1534,7 +1526,7 @@ void cmLocalVisualStudio7Generator::WriteVCProjFile(std::ostream& fout, // VS >= 8 support per-config source locations so we // list object library content as external objects. std::vector<std::string> objs; - gt->UseObjectLibraries(objs, ""); + target->UseObjectLibraries(objs, ""); if(!objs.empty()) { // TODO: Separate sub-filter for each object library used? @@ -1569,7 +1561,7 @@ class cmLocalVisualStudio7GeneratorFCInfo { public: cmLocalVisualStudio7GeneratorFCInfo(cmLocalVisualStudio7Generator* lg, - cmTarget& target, + cmGeneratorTarget* target, cmSourceFile const& sf, std::vector<std::string> const& configs); std::map<std::string, cmLVS7GFileConfig> FileConfigMap; @@ -1577,12 +1569,10 @@ public: cmLocalVisualStudio7GeneratorFCInfo ::cmLocalVisualStudio7GeneratorFCInfo(cmLocalVisualStudio7Generator* lg, - cmTarget& target, + cmGeneratorTarget* gt, cmSourceFile const& sf, std::vector<std::string> const& configs) { - cmGeneratorTarget* gt = - lg->GetGlobalGenerator()->GetGeneratorTarget(&target); std::string objectName; if(gt->HasExplicitObjectName(&sf)) { @@ -1699,10 +1689,10 @@ cmLocalVisualStudio7GeneratorFCInfo //---------------------------------------------------------------------------- std::string cmLocalVisualStudio7Generator -::ComputeLongestObjectDirectory(cmTarget& target) const +::ComputeLongestObjectDirectory(cmGeneratorTarget const* target) const { std::vector<std::string> configs; - target.GetMakefile()->GetConfigurations(configs); + target->Target->GetMakefile()->GetConfigurations(configs); // Compute the maximum length configuration name. std::string config_max; @@ -1719,7 +1709,7 @@ cmLocalVisualStudio7Generator // files directory for any configuration. This is used to construct // object file names that do not produce paths that are too long. std::string dir_max; - dir_max += this->Makefile->GetCurrentBinaryDirectory(); + dir_max += this->GetCurrentBinaryDirectory(); dir_max += "/"; dir_max += this->GetTargetDirectory(target); dir_max += "/"; @@ -1729,7 +1719,7 @@ cmLocalVisualStudio7Generator } bool cmLocalVisualStudio7Generator -::WriteGroup(const cmSourceGroup *sg, cmTarget& target, +::WriteGroup(const cmSourceGroup *sg, cmGeneratorTarget* target, std::ostream &fout, const std::string& libName, std::vector<std::string> const& configs) { @@ -1764,15 +1754,14 @@ bool cmLocalVisualStudio7Generator } // Loop through each source in the source group. - std::string objectName; for(std::vector<const cmSourceFile *>::const_iterator sf = sourceFiles.begin(); sf != sourceFiles.end(); ++sf) { std::string source = (*sf)->GetFullPath(); FCInfo fcinfo(this, target, *(*sf), configs); - if (source != libName || target.GetType() == cmTarget::UTILITY || - target.GetType() == cmTarget::GLOBAL_TARGET ) + if (source != libName || target->GetType() == cmState::UTILITY || + target->GetType() == cmState::GLOBAL_TARGET ) { fout << "\t\t\t<File\n"; std::string d = this->ConvertToXMLOutputPathSingle(source.c_str()); @@ -2019,10 +2008,10 @@ void cmLocalVisualStudio7Generator::WriteVCProjEndGroup(std::ostream& fout) void cmLocalVisualStudio7Generator ::OutputTargetRules(std::ostream& fout, const std::string& configName, - cmTarget &target, + cmGeneratorTarget *target, const std::string& /*libName*/) { - if (target.GetType() > cmTarget::GLOBAL_TARGET) + if (target->GetType() > cmState::GLOBAL_TARGET) { return; } @@ -2032,36 +2021,35 @@ void cmLocalVisualStudio7Generator const char* tool = this->FortranProject? "VFPreBuildEventTool":"VCPreBuildEventTool"; event.Start(tool); - event.Write(target.GetPreBuildCommands()); + event.Write(target->GetPreBuildCommands()); event.Finish(); // Add pre-link event. tool = this->FortranProject? "VFPreLinkEventTool":"VCPreLinkEventTool"; event.Start(tool); bool addedPrelink = false; - if (target.GetType() == cmTarget::SHARED_LIBRARY && + if (target->GetType() == cmState::SHARED_LIBRARY && this->Makefile->IsOn("CMAKE_SUPPORT_WINDOWS_EXPORT_ALL_SYMBOLS")) { - if (target.GetPropertyAsBool("WINDOWS_EXPORT_ALL_SYMBOLS")) + if (target->GetPropertyAsBool("WINDOWS_EXPORT_ALL_SYMBOLS")) { addedPrelink = true; std::vector<cmCustomCommand> commands = - target.GetPreLinkCommands(); + target->GetPreLinkCommands(); cmGlobalVisualStudioGenerator* gg = static_cast<cmGlobalVisualStudioGenerator*>(this->GlobalGenerator); - cmGeneratorTarget* gt = - this->GlobalGenerator->GetGeneratorTarget(&target); gg->AddSymbolExportCommand( - gt, commands, configName); + target, commands, configName); event.Write(commands); } } if (!addedPrelink) { - event.Write(target.GetPreLinkCommands()); + event.Write(target->GetPreLinkCommands()); } cmsys::auto_ptr<cmCustomCommand> pcc( - this->MaybeCreateImplibDir(target, configName, this->FortranProject)); + this->MaybeCreateImplibDir(target, + configName, this->FortranProject)); if(pcc.get()) { event.Write(*pcc); @@ -2071,18 +2059,18 @@ void cmLocalVisualStudio7Generator // Add post-build event. tool = this->FortranProject? "VFPostBuildEventTool":"VCPostBuildEventTool"; event.Start(tool); - event.Write(target.GetPostBuildCommands()); + event.Write(target->GetPostBuildCommands()); event.Finish(); } void cmLocalVisualStudio7Generator::WriteProjectSCC(std::ostream& fout, - cmTarget& target) + cmGeneratorTarget* target) { // if we have all the required Source code control tags // then add that to the project - const char* vsProjectname = target.GetProperty("VS_SCC_PROJECTNAME"); - const char* vsLocalpath = target.GetProperty("VS_SCC_LOCALPATH"); - const char* vsProvider = target.GetProperty("VS_SCC_PROVIDER"); + const char* vsProjectname = target->GetProperty("VS_SCC_PROJECTNAME"); + const char* vsLocalpath = target->GetProperty("VS_SCC_LOCALPATH"); + const char* vsProvider = target->GetProperty("VS_SCC_PROVIDER"); if(vsProvider && vsLocalpath && vsProjectname) { @@ -2090,7 +2078,7 @@ void cmLocalVisualStudio7Generator::WriteProjectSCC(std::ostream& fout, << "\tSccLocalPath=\"" << vsLocalpath << "\"\n" << "\tSccProvider=\"" << vsProvider << "\"\n"; - const char* vsAuxPath = target.GetProperty("VS_SCC_AUXPATH"); + const char* vsAuxPath = target->GetProperty("VS_SCC_AUXPATH"); if(vsAuxPath) { fout << "\tSccAuxPath=\"" << vsAuxPath << "\"\n"; @@ -2102,7 +2090,7 @@ void cmLocalVisualStudio7Generator ::WriteProjectStartFortran(std::ostream& fout, const std::string& libName, - cmTarget & target) + cmGeneratorTarget *target) { cmGlobalVisualStudio7Generator* gg = @@ -2112,38 +2100,38 @@ cmLocalVisualStudio7Generator << "<VisualStudioProject\n" << "\tProjectCreator=\"Intel Fortran\"\n" << "\tVersion=\"" << gg->GetIntelProjectVersion() << "\"\n"; - const char* keyword = target.GetProperty("VS_KEYWORD"); + const char* keyword = target->GetProperty("VS_KEYWORD"); if(!keyword) { keyword = "Console Application"; } const char* projectType = 0; - switch(target.GetType()) + switch(target->GetType()) { - case cmTarget::STATIC_LIBRARY: + case cmState::STATIC_LIBRARY: projectType = "typeStaticLibrary"; if(keyword) { keyword = "Static Library"; } break; - case cmTarget::SHARED_LIBRARY: - case cmTarget::MODULE_LIBRARY: + case cmState::SHARED_LIBRARY: + case cmState::MODULE_LIBRARY: projectType = "typeDynamicLibrary"; if(!keyword) { keyword = "Dll"; } break; - case cmTarget::EXECUTABLE: + case cmState::EXECUTABLE: if(!keyword) { keyword = "Console Application"; } projectType = 0; break; - case cmTarget::UTILITY: - case cmTarget::GLOBAL_TARGET: + case cmState::UTILITY: + case cmState::GLOBAL_TARGET: default: break; } @@ -2163,7 +2151,7 @@ cmLocalVisualStudio7Generator void cmLocalVisualStudio7Generator::WriteProjectStart(std::ostream& fout, const std::string& libName, - cmTarget & target, + cmGeneratorTarget *target, std::vector<cmSourceGroup> &) { if(this->FortranProject) @@ -2187,12 +2175,12 @@ cmLocalVisualStudio7Generator::WriteProjectStart(std::ostream& fout, { fout << "\tVersion=\"" << (gg->GetVersion()/10) << ".00\"\n"; } - const char* projLabel = target.GetProperty("PROJECT_LABEL"); + const char* projLabel = target->GetProperty("PROJECT_LABEL"); if(!projLabel) { projLabel = libName.c_str(); } - const char* keyword = target.GetProperty("VS_KEYWORD"); + const char* keyword = target->GetProperty("VS_KEYWORD"); if(!keyword) { keyword = "Win32Proj"; @@ -2204,7 +2192,7 @@ cmLocalVisualStudio7Generator::WriteProjectStart(std::ostream& fout, } this->WriteProjectSCC(fout, target); if(const char* targetFrameworkVersion = - target.GetProperty("VS_DOTNET_TARGET_FRAMEWORK_VERSION")) + target->GetProperty("VS_DOTNET_TARGET_FRAMEWORK_VERSION")) { fout << "\tTargetFrameworkVersion=\"" << targetFrameworkVersion << "\"\n"; } @@ -2225,22 +2213,24 @@ cmLocalVisualStudio7Generator::WriteProjectStart(std::ostream& fout, } -void cmLocalVisualStudio7Generator::WriteVCProjFooter(std::ostream& fout, - cmTarget &target) +void cmLocalVisualStudio7Generator::WriteVCProjFooter( + std::ostream& fout, + cmGeneratorTarget *target) { fout << "\t<Globals>\n"; - cmPropertyMap const& props = target.GetProperties(); - for(cmPropertyMap::const_iterator i = props.begin(); i != props.end(); ++i) + std::vector<std::string> const& props = target->GetPropertyKeys(); + for(std::vector<std::string>::const_iterator i = props.begin(); + i != props.end(); ++i) { - if(i->first.find("VS_GLOBAL_") == 0) + if(i->find("VS_GLOBAL_") == 0) { - std::string name = i->first.substr(10); + std::string name = i->substr(10); if(name != "") { fout << "\t\t<Global\n" << "\t\t\tName=\"" << name << "\"\n" - << "\t\t\tValue=\"" << i->second.GetValue() << "\"\n" + << "\t\t\tValue=\"" << target->GetProperty(*i) << "\"\n" << "\t\t/>\n"; } } @@ -2365,10 +2355,10 @@ void cmLocalVisualStudio7Generator::ReadAndStoreExternalGUID( //---------------------------------------------------------------------------- std::string cmLocalVisualStudio7Generator -::GetTargetDirectory(cmTarget const& target) const +::GetTargetDirectory(cmGeneratorTarget const* target) const { std::string dir; - dir += target.GetName(); + dir += target->GetName(); dir += ".dir"; return dir; } diff --git a/Source/cmLocalVisualStudio7Generator.h b/Source/cmLocalVisualStudio7Generator.h index bc05a06..7bb9cc6 100644 --- a/Source/cmLocalVisualStudio7Generator.h +++ b/Source/cmLocalVisualStudio7Generator.h @@ -15,7 +15,6 @@ #include "cmLocalVisualStudioGenerator.h" #include "cmVisualStudioGeneratorOptions.h" -class cmTarget; class cmSourceFile; class cmCustomCommand; class cmSourceGroup; @@ -53,16 +52,19 @@ public: */ void SetBuildType(BuildType,const std::string& name); - virtual std::string GetTargetDirectory(cmTarget const&) const; + virtual + std::string GetTargetDirectory(cmGeneratorTarget const* target) const; cmSourceFile* CreateVCProjBuildRule(); void WriteStampFiles(); - virtual std::string ComputeLongestObjectDirectory(cmTarget&) const; + virtual std::string + ComputeLongestObjectDirectory(cmGeneratorTarget const*) const; virtual void ReadAndStoreExternalGUID(const std::string& name, const char* path); virtual void AddCMakeListsRules(); protected: - void CreateSingleVCProj(const std::string& lname, cmTarget &tgt); + void CreateSingleVCProj(const std::string& lname, + cmGeneratorTarget *tgt); private: typedef cmVisualStudioGeneratorOptions Options; typedef cmLocalVisualStudio7GeneratorFCInfo FCInfo; @@ -71,30 +73,33 @@ private: void FixGlobalTargets(); void WriteProjectFiles(); void WriteVCProjHeader(std::ostream& fout, const std::string& libName, - cmTarget &tgt, std::vector<cmSourceGroup> &sgs); - void WriteVCProjFooter(std::ostream& fout, cmTarget &target); + cmGeneratorTarget* tgt, + std::vector<cmSourceGroup> &sgs); + void WriteVCProjFooter(std::ostream& fout, cmGeneratorTarget* target); void WriteVCProjFile(std::ostream& fout, const std::string& libName, - cmTarget &tgt); + cmGeneratorTarget* tgt); void WriteConfigurations(std::ostream& fout, std::vector<std::string> const& configs, - const std::string& libName, cmTarget &tgt); + const std::string& libName, cmGeneratorTarget* tgt); void WriteConfiguration(std::ostream& fout, const std::string& configName, - const std::string& libName, cmTarget &tgt); + const std::string& libName, cmGeneratorTarget* tgt); std::string EscapeForXML(const std::string& s); std::string ConvertToXMLOutputPath(const char* path); std::string ConvertToXMLOutputPathSingle(const char* path); void OutputTargetRules(std::ostream& fout, const std::string& configName, - cmTarget &target, const std::string& libName); + cmGeneratorTarget* target, + const std::string& libName); void OutputBuildTool(std::ostream& fout, const std::string& configName, - cmTarget& t, const Options& targetOptions); + cmGeneratorTarget* t, const Options& targetOptions); void OutputLibraryDirectories(std::ostream& fout, std::vector<std::string> const& dirs); - void WriteProjectSCC(std::ostream& fout, cmTarget& target); + void WriteProjectSCC(std::ostream& fout, cmGeneratorTarget *target); void WriteProjectStart(std::ostream& fout, const std::string& libName, - cmTarget &tgt, std::vector<cmSourceGroup> &sgs); + cmGeneratorTarget* tgt, + std::vector<cmSourceGroup> &sgs); void WriteProjectStartFortran(std::ostream& fout, const std::string& libName, - cmTarget &tgt); + cmGeneratorTarget* tgt); void WriteVCProjBeginGroup(std::ostream& fout, const char* group, const char* filter); @@ -105,10 +110,11 @@ private: const char* source, const cmCustomCommand& command, FCInfo& fcinfo); - void WriteTargetVersionAttribute(std::ostream& fout, cmTarget& target); + void WriteTargetVersionAttribute(std::ostream& fout, + cmGeneratorTarget* gt); bool WriteGroup(const cmSourceGroup *sg, - cmTarget& target, std::ostream &fout, + cmGeneratorTarget* target, std::ostream &fout, const std::string& libName, std::vector<std::string> const& configs); diff --git a/Source/cmLocalVisualStudioGenerator.cxx b/Source/cmLocalVisualStudioGenerator.cxx index c0072de..561f9a1 100644 --- a/Source/cmLocalVisualStudioGenerator.cxx +++ b/Source/cmLocalVisualStudioGenerator.cxx @@ -43,7 +43,7 @@ void cmLocalVisualStudioGenerator::ComputeObjectFilenames( std::map<cmSourceFile const*, std::string>& mapping, cmGeneratorTarget const* gt) { - std::string dir_max = this->ComputeLongestObjectDirectory(*gt->Target); + std::string dir_max = this->ComputeLongestObjectDirectory(gt); // Count the number of object files with each name. Note that // windows file names are not case sensitive. @@ -80,7 +80,7 @@ void cmLocalVisualStudioGenerator::ComputeObjectFilenames( //---------------------------------------------------------------------------- cmsys::auto_ptr<cmCustomCommand> -cmLocalVisualStudioGenerator::MaybeCreateImplibDir(cmTarget& target, +cmLocalVisualStudioGenerator::MaybeCreateImplibDir(cmGeneratorTarget* target, const std::string& config, bool isFortran) { @@ -89,11 +89,11 @@ cmLocalVisualStudioGenerator::MaybeCreateImplibDir(cmTarget& target, // If an executable exports symbols then VS wants to create an // import library but forgets to create the output directory. // The Intel Fortran plugin always forgets to the directory. - if(target.GetType() != cmTarget::EXECUTABLE && - !(isFortran && target.GetType() == cmTarget::SHARED_LIBRARY)) + if(target->GetType() != cmState::EXECUTABLE && + !(isFortran && target->GetType() == cmState::SHARED_LIBRARY)) { return pcc; } - std::string outDir = target.GetDirectory(config, false); - std::string impDir = target.GetDirectory(config, true); + std::string outDir = target->GetDirectory(config, false); + std::string impDir = target->GetDirectory(config, true); if(impDir == outDir) { return pcc; } // Add a pre-build event to create the directory. diff --git a/Source/cmLocalVisualStudioGenerator.h b/Source/cmLocalVisualStudioGenerator.h index 071bfb3..f95eefa 100644 --- a/Source/cmLocalVisualStudioGenerator.h +++ b/Source/cmLocalVisualStudioGenerator.h @@ -44,7 +44,8 @@ public: cmGlobalVisualStudioGenerator::VSVersion GetVersion() const; - virtual std::string ComputeLongestObjectDirectory(cmTarget&) const = 0; + virtual std::string + ComputeLongestObjectDirectory(cmGeneratorTarget const*) const = 0; virtual void AddCMakeListsRules() = 0; @@ -58,7 +59,8 @@ protected: /** Construct a custom command to make exe import lib dir. */ cmsys::auto_ptr<cmCustomCommand> - MaybeCreateImplibDir(cmTarget& target, const std::string& config, + MaybeCreateImplibDir(cmGeneratorTarget *target, + const std::string& config, bool isFortran); }; diff --git a/Source/cmLocalXCodeGenerator.cxx b/Source/cmLocalXCodeGenerator.cxx index b19112d..aec2603 100644 --- a/Source/cmLocalXCodeGenerator.cxx +++ b/Source/cmLocalXCodeGenerator.cxx @@ -31,7 +31,7 @@ cmLocalXCodeGenerator::~cmLocalXCodeGenerator() //---------------------------------------------------------------------------- std::string -cmLocalXCodeGenerator::GetTargetDirectory(cmTarget const&) const +cmLocalXCodeGenerator::GetTargetDirectory(cmGeneratorTarget const*) const { // No per-target directory for this generator (yet). return ""; @@ -51,12 +51,11 @@ void cmLocalXCodeGenerator::Generate() { cmLocalGenerator::Generate(); - cmTargets& targets = this->Makefile->GetTargets(); - for(cmTargets::iterator iter = targets.begin(); + std::vector<cmGeneratorTarget*> targets = this->GetGeneratorTargets(); + for(std::vector<cmGeneratorTarget*>::iterator iter = targets.begin(); iter != targets.end(); ++iter) { - cmTarget* t = &iter->second; - t->HasMacOSXRpathInstallNameDir(""); + (*iter)->HasMacOSXRpathInstallNameDir(""); } } @@ -65,12 +64,11 @@ void cmLocalXCodeGenerator::GenerateInstallRules() { cmLocalGenerator::GenerateInstallRules(); - cmTargets& targets = this->Makefile->GetTargets(); - for(cmTargets::iterator iter = targets.begin(); + std::vector<cmGeneratorTarget*> targets = this->GetGeneratorTargets(); + for(std::vector<cmGeneratorTarget*>::iterator iter = targets.begin(); iter != targets.end(); ++iter) { - cmTarget* t = &iter->second; - t->HasMacOSXRpathInstallNameDir(""); + (*iter)->HasMacOSXRpathInstallNameDir(""); } } diff --git a/Source/cmLocalXCodeGenerator.h b/Source/cmLocalXCodeGenerator.h index 6d0926f..4381a6d 100644 --- a/Source/cmLocalXCodeGenerator.h +++ b/Source/cmLocalXCodeGenerator.h @@ -28,7 +28,8 @@ public: cmMakefile* mf); virtual ~cmLocalXCodeGenerator(); - virtual std::string GetTargetDirectory(cmTarget const& target) const; + virtual + std::string GetTargetDirectory(cmGeneratorTarget const* target) const; virtual void AppendFlagEscape(std::string& flags, const std::string& rawFlag); virtual void Generate(); diff --git a/Source/cmMakeDepend.cxx b/Source/cmMakeDepend.cxx deleted file mode 100644 index cbc7e02..0000000 --- a/Source/cmMakeDepend.cxx +++ /dev/null @@ -1,361 +0,0 @@ -/*============================================================================ - 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 "cmMakeDepend.h" -#include "cmSystemTools.h" -#include "cmGeneratorExpression.h" -#include "cmAlgorithms.h" - -#include <cmsys/RegularExpression.hxx> -#include <cmsys/FStream.hxx> - -void cmDependInformation::AddDependencies(cmDependInformation* info) -{ - if(this != info) - { - this->DependencySet.insert(info); - } -} - -cmMakeDepend::cmMakeDepend() -{ - this->Verbose = false; - this->IncludeFileRegularExpression.compile("^.*$"); - this->ComplainFileRegularExpression.compile("^$"); -} - - -cmMakeDepend::~cmMakeDepend() -{ - cmDeleteAll(this->DependInformationMap); -} - - -// Set the makefile that depends will be made from. -// The pointer is kept so the cmSourceFile array can -// be updated with the depend information in the cmMakefile. - -void cmMakeDepend::SetMakefile(cmMakefile* makefile) -{ - this->Makefile = makefile; - - // Now extract the include file regular expression from the makefile. - this->IncludeFileRegularExpression.compile( - this->Makefile->GetIncludeRegularExpression()); - this->ComplainFileRegularExpression.compile( - this->Makefile->ComplainFileRegularExpression.c_str()); - - // Now extract any include paths from the targets - std::set<std::string> uniqueIncludes; - std::vector<std::string> orderedAndUniqueIncludes; - cmTargets &targets = this->Makefile->GetTargets(); - for (cmTargets::iterator l = targets.begin(); - l != targets.end(); ++l) - { - const char *incDirProp = l->second.GetProperty("INCLUDE_DIRECTORIES"); - if (!incDirProp) - { - continue; - } - - std::string incDirs = cmGeneratorExpression::Preprocess(incDirProp, - cmGeneratorExpression::StripAllGeneratorExpressions); - - std::vector<std::string> includes; - cmSystemTools::ExpandListArgument(incDirs, includes); - - for(std::vector<std::string>::const_iterator j = includes.begin(); - j != includes.end(); ++j) - { - std::string path = *j; - this->Makefile->ExpandVariablesInString(path); - if(uniqueIncludes.insert(path).second) - { - orderedAndUniqueIncludes.push_back(path); - } - } - } - - for(std::vector<std::string>::const_iterator - it = orderedAndUniqueIncludes.begin(); - it != orderedAndUniqueIncludes.end(); - ++it) - { - this->AddSearchPath(*it); - } -} - - -const cmDependInformation* cmMakeDepend::FindDependencies(const char* file) -{ - cmDependInformation* info = this->GetDependInformation(file,0); - this->GenerateDependInformation(info); - return info; -} - -void cmMakeDepend::GenerateDependInformation(cmDependInformation* info) -{ - // If dependencies are already done, stop now. - if(info->DependDone) - { - return; - } - else - { - // Make sure we don't visit the same file more than once. - info->DependDone = true; - } - const char* path = info->FullPath.c_str(); - if(!path) - { - cmSystemTools::Error( - "Attempt to find dependencies for file without path!"); - return; - } - - bool found = false; - - // If the file exists, use it to find dependency information. - if(cmSystemTools::FileExists(path, true)) - { - // Use the real file to find its dependencies. - this->DependWalk(info); - found = true; - } - - - // See if the cmSourceFile for it has any files specified as - // dependency hints. - if(info->SourceFile != 0) - { - - // Get the cmSourceFile corresponding to this. - const cmSourceFile& cFile = *(info->SourceFile); - // See if there are any hints for finding dependencies for the missing - // file. - if(!cFile.GetDepends().empty()) - { - // Dependency hints have been given. Use them to begin the - // recursion. - for(std::vector<std::string>::const_iterator file = - cFile.GetDepends().begin(); file != cFile.GetDepends().end(); - ++file) - { - this->AddDependency(info, file->c_str()); - } - - // Found dependency information. We are done. - found = true; - } - } - - if(!found) - { - // Try to find the file amongst the sources - cmSourceFile *srcFile = this->Makefile->GetSource - (cmSystemTools::GetFilenameWithoutExtension(path)); - if (srcFile) - { - if (srcFile->GetFullPath() == path) - { - found=true; - } - else - { - //try to guess which include path to use - for(std::vector<std::string>::iterator t = - this->IncludeDirectories.begin(); - t != this->IncludeDirectories.end(); ++t) - { - std::string incpath = *t; - if (!incpath.empty() && incpath[incpath.size() - 1] != '/') - { - incpath = incpath + "/"; - } - incpath = incpath + path; - if (srcFile->GetFullPath() == incpath) - { - // set the path to the guessed path - info->FullPath = incpath; - found=true; - } - } - } - } - } - - if(!found) - { - // Couldn't find any dependency information. - if(this->ComplainFileRegularExpression.find(info->IncludeName.c_str())) - { - cmSystemTools::Error("error cannot find dependencies for ", path); - } - else - { - // Destroy the name of the file so that it won't be output as a - // dependency. - info->FullPath = ""; - } - } -} - -// This function actually reads the file specified and scans it for -// #include directives -void cmMakeDepend::DependWalk(cmDependInformation* info) -{ - cmsys::RegularExpression includeLine - ("^[ \t]*#[ \t]*include[ \t]*[<\"]([^\">]+)[\">]"); - cmsys::ifstream fin(info->FullPath.c_str()); - if(!fin) - { - cmSystemTools::Error("Cannot open ", info->FullPath.c_str()); - return; - } - - // TODO: Write real read loop (see cmSystemTools::CopyFile). - std::string line; - while( cmSystemTools::GetLineFromStream(fin, line) ) - { - if(includeLine.find(line.c_str())) - { - // extract the file being included - std::string includeFile = includeLine.match(1); - // see if the include matches the regular expression - if(!this->IncludeFileRegularExpression.find(includeFile)) - { - if(this->Verbose) - { - std::string message = "Skipping "; - message += includeFile; - message += " for file "; - message += info->FullPath.c_str(); - cmSystemTools::Error(message.c_str(), 0); - } - continue; - } - - // Add this file and all its dependencies. - this->AddDependency(info, includeFile.c_str()); - } - } -} - - -void cmMakeDepend::AddDependency(cmDependInformation* info, const char* file) -{ - cmDependInformation* dependInfo = - this->GetDependInformation(file, info->PathOnly.c_str()); - this->GenerateDependInformation(dependInfo); - info->AddDependencies(dependInfo); -} - -cmDependInformation* cmMakeDepend::GetDependInformation(const char* file, - const char *extraPath) -{ - // Get the full path for the file so that lookup is unambiguous. - std::string fullPath = this->FullPath(file, extraPath); - - // Try to find the file's instance of cmDependInformation. - DependInformationMapType::const_iterator result = - this->DependInformationMap.find(fullPath); - if(result != this->DependInformationMap.end()) - { - // Found an instance, return it. - return result->second; - } - else - { - // Didn't find an instance. Create a new one and save it. - cmDependInformation* info = new cmDependInformation; - info->FullPath = fullPath; - info->PathOnly = cmSystemTools::GetFilenamePath(fullPath); - info->IncludeName = file; - this->DependInformationMap[fullPath] = info; - return info; - } -} - - -// find the full path to fname by searching the this->IncludeDirectories array -std::string cmMakeDepend::FullPath(const char* fname, const char *extraPath) -{ - DirectoryToFileToPathMapType::iterator m; - if(extraPath) - { - m = this->DirectoryToFileToPathMap.find(extraPath); - } - else - { - m = this->DirectoryToFileToPathMap.find(""); - } - - if(m != this->DirectoryToFileToPathMap.end()) - { - FileToPathMapType& map = m->second; - FileToPathMapType::iterator p = map.find(fname); - if(p != map.end()) - { - return p->second; - } - } - - if(cmSystemTools::FileExists(fname, true)) - { - std::string fp = cmSystemTools::CollapseFullPath(fname); - this->DirectoryToFileToPathMap[extraPath? extraPath: ""][fname] = fp; - return fp; - } - - for(std::vector<std::string>::iterator i = this->IncludeDirectories.begin(); - i != this->IncludeDirectories.end(); ++i) - { - std::string path = *i; - if (!path.empty() && path[path.size() - 1] != '/') - { - path = path + "/"; - } - path = path + fname; - if(cmSystemTools::FileExists(path.c_str(), true) - && !cmSystemTools::FileIsDirectory(path)) - { - std::string fp = cmSystemTools::CollapseFullPath(path); - this->DirectoryToFileToPathMap[extraPath? extraPath: ""][fname] = fp; - return fp; - } - } - - if (extraPath) - { - std::string path = extraPath; - if (!path.empty() && path[path.size() - 1] != '/') - { - path = path + "/"; - } - path = path + fname; - if(cmSystemTools::FileExists(path.c_str(), true) - && !cmSystemTools::FileIsDirectory(path)) - { - std::string fp = cmSystemTools::CollapseFullPath(path); - this->DirectoryToFileToPathMap[extraPath][fname] = fp; - return fp; - } - } - - // Couldn't find the file. - return std::string(fname); -} - -// Add a directory to the search path -void cmMakeDepend::AddSearchPath(const std::string& path) -{ - this->IncludeDirectories.push_back(path); -} diff --git a/Source/cmMakeDepend.h b/Source/cmMakeDepend.h deleted file mode 100644 index 2c9d515..0000000 --- a/Source/cmMakeDepend.h +++ /dev/null @@ -1,150 +0,0 @@ -/*============================================================================ - 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. -============================================================================*/ -#ifndef cmMakeDepend_h -#define cmMakeDepend_h - -#include "cmMakefile.h" -#include "cmSourceFile.h" - -#include <cmsys/RegularExpression.hxx> - -/** \class cmDependInformation - * \brief Store dependency information for a single source file. - * - * This structure stores the depend information for a single source file. - */ -class cmDependInformation -{ -public: - /** - * Construct with dependency generation marked not done; instance - * not placed in cmMakefile's list. - */ - cmDependInformation(): DependDone(false), SourceFile(0) {} - - /** - * The set of files on which this one depends. - */ - typedef std::set<cmDependInformation*> DependencySetType; - DependencySetType DependencySet; - - /** - * This flag indicates whether dependency checking has been - * performed for this file. - */ - bool DependDone; - - /** - * If this object corresponds to a cmSourceFile instance, this points - * to it. - */ - const cmSourceFile *SourceFile; - - /** - * Full path to this file. - */ - std::string FullPath; - - /** - * Full path not including file name. - */ - std::string PathOnly; - - /** - * Name used to #include this file. - */ - std::string IncludeName; - - /** - * This method adds the dependencies of another file to this one. - */ - void AddDependencies(cmDependInformation*); -}; - - -// cmMakeDepend is used to generate dependancy information for -// the classes in a makefile -class cmMakeDepend -{ -public: - /** - * Construct the object with verbose turned off. - */ - cmMakeDepend(); - - /** - * Destructor. - */ - virtual ~cmMakeDepend(); - - /** - * Set the makefile that is used as a source of classes. - */ - virtual void SetMakefile(cmMakefile* makefile); - - /** - * Add a directory to the search path for include files. - */ - virtual void AddSearchPath(const std::string&); - - /** - * Generate dependencies for the file given. Returns a pointer to - * the cmDependInformation object for the file. - */ - const cmDependInformation* FindDependencies(const char* file); - -protected: - /** - * Compute the depend information for this class. - */ - virtual void DependWalk(cmDependInformation* info); - - /** - * Add a dependency. Possibly walk it for more dependencies. - */ - virtual void AddDependency(cmDependInformation* info, const char* file); - - /** - * Fill in the given object with dependency information. If the - * information is already complete, nothing is done. - */ - void GenerateDependInformation(cmDependInformation* info); - - /** - * Get an instance of cmDependInformation corresponding to the given file - * name. - */ - cmDependInformation* GetDependInformation(const char* file, - const char *extraPath); - - /** - * Find the full path name for the given file name. - * This uses the include directories. - * TODO: Cache path conversions to reduce FileExists calls. - */ - std::string FullPath(const char *filename, const char *extraPath); - - cmMakefile* Makefile; - bool Verbose; - cmsys::RegularExpression IncludeFileRegularExpression; - cmsys::RegularExpression ComplainFileRegularExpression; - std::vector<std::string> IncludeDirectories; - typedef std::map<std::string, std::string> FileToPathMapType; - typedef std::map<std::string, FileToPathMapType> - DirectoryToFileToPathMapType; - typedef std::map<std::string, cmDependInformation*> - DependInformationMapType; - DependInformationMapType DependInformationMap; - DirectoryToFileToPathMapType DirectoryToFileToPathMap; -}; - -#endif diff --git a/Source/cmMakefile.cxx b/Source/cmMakefile.cxx index 3c19f55..47e1731 100644 --- a/Source/cmMakefile.cxx +++ b/Source/cmMakefile.cxx @@ -50,46 +50,16 @@ cmMakefile::cmMakefile(cmGlobalGenerator* globalGenerator, { this->IsSourceFileTryCompile = false; - // Initialize these first since AddDefaultDefinitions calls AddDefinition this->WarnUnused = this->GetCMakeInstance()->GetWarnUnused(); this->CheckSystemVars = this->GetCMakeInstance()->GetCheckSystemVars(); this->SuppressWatches = false; - // Setup the default include file regular expression (match everything). - this->SetProperty("INCLUDE_REGULAR_EXPRESSION", "^.*$"); // Setup the default include complaint regular expression (match nothing). this->ComplainFileRegularExpression = "^$"; - // Source and header file extensions that we can handle - - // Set up a list of source and header extensions - // these are used to find files when the extension - // is not given - // The "c" extension MUST precede the "C" extension. - this->SourceFileExtensions.push_back( "c" ); - this->SourceFileExtensions.push_back( "C" ); - - this->SourceFileExtensions.push_back( "c++" ); - this->SourceFileExtensions.push_back( "cc" ); - this->SourceFileExtensions.push_back( "cpp" ); - this->SourceFileExtensions.push_back( "cxx" ); - this->SourceFileExtensions.push_back( "m" ); - this->SourceFileExtensions.push_back( "M" ); - this->SourceFileExtensions.push_back( "mm" ); - - this->HeaderFileExtensions.push_back( "h" ); - this->HeaderFileExtensions.push_back( "hh" ); - this->HeaderFileExtensions.push_back( "h++" ); - this->HeaderFileExtensions.push_back( "hm" ); - this->HeaderFileExtensions.push_back( "hpp" ); - this->HeaderFileExtensions.push_back( "hxx" ); - this->HeaderFileExtensions.push_back( "in" ); - this->HeaderFileExtensions.push_back( "txx" ); this->DefineFlags = " "; - this->AddDefaultDefinitions(); - this->cmDefineRegex.compile("#cmakedefine[ \t]+([A-Za-z_0-9]*)"); this->cmDefine01Regex.compile("#cmakedefine01[ \t]+([A-Za-z_0-9]*)"); this->cmAtVarRegex.compile("(@[A-Za-z_0-9/.+-]+@)"); @@ -119,17 +89,6 @@ cmMakefile::cmMakefile(cmGlobalGenerator* globalGenerator, this->AddSourceGroup("Resources", "\\.plist$"); this->AddSourceGroup("Object Files", "\\.(lo|o|obj)$"); #endif - - { - const char* dir = this->GetCMakeInstance()->GetHomeDirectory(); - this->AddDefinition("CMAKE_SOURCE_DIR", dir); - this->AddDefinition("CMAKE_CURRENT_SOURCE_DIR", dir); - } - { - const char* dir = this->GetCMakeInstance()->GetHomeOutputDirectory(); - this->AddDefinition("CMAKE_BINARY_DIR", dir); - this->AddDefinition("CMAKE_CURRENT_BINARY_DIR", dir); - } } cmMakefile::~cmMakefile() @@ -142,9 +101,6 @@ cmMakefile::~cmMakefile() cmDeleteAll(this->FinalPassCommands); cmDeleteAll(this->FunctionBlockers); cmDeleteAll(this->EvaluationFiles); - this->EvaluationFiles.clear(); - - this->FunctionBlockers.clear(); } //---------------------------------------------------------------------------- @@ -686,6 +642,29 @@ cmMakefile::GetEvaluationFiles() const return this->EvaluationFiles; } +std::vector<cmExportBuildFileGenerator*> +cmMakefile::GetExportBuildFileGenerators() const +{ + return this->ExportBuildFileGenerators; +} + +void cmMakefile::RemoveExportBuildFileGeneratorCMP0024( + cmExportBuildFileGenerator* gen) +{ + std::vector<cmExportBuildFileGenerator*>::iterator it = + std::find(this->ExportBuildFileGenerators.begin(), + this->ExportBuildFileGenerators.end(), gen); + if(it != this->ExportBuildFileGenerators.end()) + { + this->ExportBuildFileGenerators.erase(it); + } +} + +void cmMakefile::AddExportBuildFileGenerator(cmExportBuildFileGenerator* gen) +{ + this->ExportBuildFileGenerators.push_back(gen); +} + namespace { struct file_not_persistent @@ -752,15 +731,26 @@ void cmMakefile::ConfigureFinalPass() "with CMake 2.4 or later. For compatibility with older versions please " "use any CMake 2.8.x release or lower."); } - for (cmTargets::iterator l = this->Targets.begin(); - l != this->Targets.end(); l++) +#if defined(_WIN32) && !defined(__CYGWIN__) + // Do old-style link dependency analysis only for CM_USE_OLD_VS6. + if(this->GetGlobalGenerator()->IsForVS6()) { - if (l->second.GetType() == cmTarget::INTERFACE_LIBRARY) + for (cmTargets::iterator l = this->Targets.begin(); + l != this->Targets.end(); l++) { - continue; + if (l->second.GetType() == cmState::INTERFACE_LIBRARY) + { + continue; + } + // Erase any cached link information that might have been comptued + // on-demand during the configuration. This ensures that build + // system generation uses up-to-date information even if other cache + // invalidation code in this source file is buggy. + + l->second.AnalyzeLibDependenciesForVS6(*this); } - l->second.FinishConfigure(); } +#endif } //---------------------------------------------------------------------------- @@ -806,7 +796,7 @@ cmMakefile::AddCustomCommandToTarget(const std::string& target, return; } - if(ti->second.GetType() == cmTarget::OBJECT_LIBRARY) + if(ti->second.GetType() == cmState::OBJECT_LIBRARY) { std::ostringstream e; e << "Target \"" << target << "\" is an OBJECT library " @@ -814,7 +804,7 @@ cmMakefile::AddCustomCommandToTarget(const std::string& target, this->IssueMessage(cmake::FATAL_ERROR, e.str()); return; } - if(ti->second.GetType() == cmTarget::INTERFACE_LIBRARY) + if(ti->second.GetType() == cmState::INTERFACE_LIBRARY) { std::ostringstream e; e << "Target \"" << target << "\" is an INTERFACE library " @@ -1180,7 +1170,7 @@ cmMakefile::AddUtilityCommand(const std::string& utilityName, bool uses_terminal) { // Create a target instance for this utility. - cmTarget* target = this->AddNewTarget(cmTarget::UTILITY, utilityName); + cmTarget* target = this->AddNewTarget(cmState::UTILITY, utilityName); if (excludeFromAll) { target->SetProperty("EXCLUDE_FROM_ALL", "TRUE"); @@ -1396,7 +1386,7 @@ bool cmMakefile::ParseDefineFlag(std::string const& def, bool remove) } void cmMakefile::AddLinkLibrary(const std::string& lib, - cmTarget::LinkLibraryType llt) + cmTargetLinkLibraryType llt) { cmTarget::LibraryID tmp; tmp.first = lib; @@ -1406,7 +1396,7 @@ void cmMakefile::AddLinkLibrary(const std::string& lib, void cmMakefile::AddLinkLibraryForTarget(const std::string& target, const std::string& lib, - cmTarget::LinkLibraryType llt) + cmTargetLinkLibraryType llt) { cmTargets::iterator i = this->Targets.find(target); if ( i != this->Targets.end()) @@ -1415,14 +1405,14 @@ void cmMakefile::AddLinkLibraryForTarget(const std::string& target, if(tgt) { // if it is not a static or shared library then you can not link to it - if(!((tgt->GetType() == cmTarget::STATIC_LIBRARY) || - (tgt->GetType() == cmTarget::SHARED_LIBRARY) || - (tgt->GetType() == cmTarget::INTERFACE_LIBRARY) || + if(!((tgt->GetType() == cmState::STATIC_LIBRARY) || + (tgt->GetType() == cmState::SHARED_LIBRARY) || + (tgt->GetType() == cmState::INTERFACE_LIBRARY) || tgt->IsExecutableWithExports())) { std::ostringstream e; e << "Target \"" << lib << "\" of type " - << cmTarget::GetTargetTypeName(tgt->GetType()) + << cmState::GetTargetTypeName(tgt->GetType()) << " may not be linked into another target. " << "One may link only to STATIC or SHARED libraries, or " << "to executables with the ENABLE_EXPORTS property set."; @@ -1467,18 +1457,11 @@ void cmMakefile::AddLinkDirectoryForTarget(const std::string& target, void cmMakefile::AddLinkLibrary(const std::string& lib) { - this->AddLinkLibrary(lib,cmTarget::GENERAL); + this->AddLinkLibrary(lib,GENERAL_LibraryType); } void cmMakefile::InitializeFromParent(cmMakefile* parent) { - this->StateSnapshot.InitializeFromParent(); - - this->AddDefinition("CMAKE_CURRENT_SOURCE_DIR", - this->GetCurrentSourceDirectory()); - this->AddDefinition("CMAKE_CURRENT_BINARY_DIR", - this->GetCurrentBinaryDirectory()); - this->SystemIncludeDirectories = parent->SystemIncludeDirectories; // define flags @@ -1517,7 +1500,7 @@ void cmMakefile::InitializeFromParent(cmMakefile* parent) parent->GetProperty("LINK_DIRECTORIES")); // the initial project name - this->SetProjectName(parent->GetProjectName()); + this->StateSnapshot.SetProjectName(parent->StateSnapshot.GetProjectName()); // Copy include regular expressions. this->ComplainFileRegularExpression = parent->ComplainFileRegularExpression; @@ -1673,6 +1656,7 @@ void cmMakefile::Configure() std::vector<cmMakefile*>::iterator sdi = subdirs.begin(); for (; sdi != subdirs.end(); ++sdi) { + (*sdi)->StateSnapshot.InitializeFromParent_ForSubdirsCommand(); this->ConfigureSubDirectory(*sdi); } @@ -1749,12 +1733,14 @@ void cmMakefile::AddSubDirectory(const std::string& srcPath, this->ContextStack.back()->Name, this->ContextStack.back()->Line); + newSnapshot.GetDirectory().SetCurrentSource(srcPath); + newSnapshot.GetDirectory().SetCurrentBinary(binPath); + + cmSystemTools::MakeDirectory(binPath.c_str()); + cmMakefile* subMf = new cmMakefile(this->GlobalGenerator, newSnapshot); this->GetGlobalGenerator()->AddMakefile(subMf); - // set the subdirs start dirs - subMf->SetCurrentSourceDirectory(srcPath); - subMf->SetCurrentBinaryDirectory(binPath); if(excludeFromAll) { subMf->SetProperty("EXCLUDE_FROM_ALL", "TRUE"); @@ -1770,35 +1756,26 @@ void cmMakefile::AddSubDirectory(const std::string& srcPath, } } -void cmMakefile::SetCurrentSourceDirectory(const std::string& dir) -{ - this->StateSnapshot.GetDirectory().SetCurrentSource(dir); - this->AddDefinition("CMAKE_CURRENT_SOURCE_DIR", - this->StateSnapshot.GetDirectory().GetCurrentSource()); -} - const char* cmMakefile::GetCurrentSourceDirectory() const { return this->StateSnapshot.GetDirectory().GetCurrentSource(); } -void cmMakefile::SetCurrentBinaryDirectory(const std::string& dir) -{ - this->StateSnapshot.GetDirectory().SetCurrentBinary(dir); - const char* binDir = this->StateSnapshot.GetDirectory().GetCurrentBinary(); - cmSystemTools::MakeDirectory(binDir); - this->AddDefinition("CMAKE_CURRENT_BINARY_DIR", binDir); -} - const char* cmMakefile::GetCurrentBinaryDirectory() const { return this->StateSnapshot.GetDirectory().GetCurrentBinary(); } -void cmMakefile::AddGeneratorTarget(cmTarget* t, cmGeneratorTarget* gt) +std::vector<cmTarget*> cmMakefile::GetImportedTargets() const { - this->GeneratorTargets[t] = gt; - this->GetGlobalGenerator()->AddGeneratorTarget(t, gt); + std::vector<cmTarget*> tgts; + tgts.reserve(this->ImportedTargets.size()); + for (TargetMap::const_iterator it = this->ImportedTargets.begin(); + it != this->ImportedTargets.end(); ++it) + { + tgts.push_back(it->second); + } + return tgts; } //---------------------------------------------------------------------------- @@ -1911,13 +1888,13 @@ void cmMakefile::AddCacheDefinition(const std::string& name, const char* value, nvalue += files[cc]; } - this->GetState()->AddCacheEntry(name, nvalue.c_str(), doc, type); + this->GetCMakeInstance()->AddCacheEntry(name, nvalue.c_str(), doc, type); val = this->GetState()->GetInitializedCacheValue(name); haveVal = true; } } - this->GetState()->AddCacheEntry(name, haveVal ? val.c_str() : 0, + this->GetCMakeInstance()->AddCacheEntry(name, haveVal ? val.c_str() : 0, doc, type); // if there was a definition then remove it this->StateSnapshot.RemoveDefinition(name); @@ -2033,20 +2010,15 @@ void cmMakefile::SetProjectName(std::string const& p) this->StateSnapshot.SetProjectName(p); } -std::string cmMakefile::GetProjectName() const -{ - return this->StateSnapshot.GetProjectName(); -} - void cmMakefile::AddGlobalLinkInformation(const std::string& name, cmTarget& target) { // for these targets do not add anything switch(target.GetType()) { - case cmTarget::UTILITY: - case cmTarget::GLOBAL_TARGET: - case cmTarget::INTERFACE_LIBRARY: + case cmState::UTILITY: + case cmState::GLOBAL_TARGET: + case cmState::INTERFACE_LIBRARY: return; default:; } @@ -2076,27 +2048,28 @@ void cmMakefile::AddGlobalLinkInformation(const std::string& name, } -void cmMakefile::AddAlias(const std::string& lname, cmTarget *tgt) +void cmMakefile::AddAlias(const std::string& lname, + std::string const& tgtName) { - this->AliasTargets[lname] = tgt; - this->GetGlobalGenerator()->AddAlias(lname, tgt); + this->AliasTargets[lname] = tgtName; + this->GetGlobalGenerator()->AddAlias(lname, tgtName); } cmTarget* cmMakefile::AddLibrary(const std::string& lname, - cmTarget::TargetType type, + cmState::TargetType type, const std::vector<std::string> &srcs, bool excludeFromAll) { // wrong type ? default to STATIC - if ( (type != cmTarget::STATIC_LIBRARY) - && (type != cmTarget::SHARED_LIBRARY) - && (type != cmTarget::MODULE_LIBRARY) - && (type != cmTarget::OBJECT_LIBRARY) - && (type != cmTarget::INTERFACE_LIBRARY)) + if ( (type != cmState::STATIC_LIBRARY) + && (type != cmState::SHARED_LIBRARY) + && (type != cmState::MODULE_LIBRARY) + && (type != cmState::OBJECT_LIBRARY) + && (type != cmState::INTERFACE_LIBRARY)) { this->IssueMessage(cmake::INTERNAL_ERROR, "cmMakefile::AddLibrary given invalid target type."); - type = cmTarget::STATIC_LIBRARY; + type = cmState::STATIC_LIBRARY; } cmTarget* target = this->AddNewTarget(type, lname); @@ -2117,7 +2090,7 @@ cmTarget* cmMakefile::AddExecutable(const char *exeName, const std::vector<std::string> &srcs, bool excludeFromAll) { - cmTarget* target = this->AddNewTarget(cmTarget::EXECUTABLE, exeName); + cmTarget* target = this->AddNewTarget(cmState::EXECUTABLE, exeName); if(excludeFromAll) { target->SetProperty("EXCLUDE_FROM_ALL", "TRUE"); @@ -2129,14 +2102,13 @@ cmTarget* cmMakefile::AddExecutable(const char *exeName, //---------------------------------------------------------------------------- cmTarget* -cmMakefile::AddNewTarget(cmTarget::TargetType type, const std::string& name) +cmMakefile::AddNewTarget(cmState::TargetType type, const std::string& name) { cmTargets::iterator it = this->Targets.insert(cmTargets::value_type(name, cmTarget())).first; cmTarget& target = it->second; target.SetType(type, name); target.SetMakefile(this); - this->GetGlobalGenerator()->AddTarget(&it->second); return &it->second; } @@ -2200,7 +2172,7 @@ cmMakefile::GetSourceGroup(const std::vector<std::string>&name) const { cmSourceGroup* sg = 0; - // first look for source group starting with the same as the one we wants + // first look for source group starting with the same as the one we want for (std::vector<cmSourceGroup>::const_iterator sgIt = this->SourceGroups.begin(); sgIt != this->SourceGroups.end(); ++sgIt) @@ -2233,7 +2205,7 @@ void cmMakefile::AddSourceGroup(const std::string& name, { std::vector<std::string> nameVector; nameVector.push_back(name); - AddSourceGroup(nameVector, regex); + this->AddSourceGroup(nameVector, regex); } void cmMakefile::AddSourceGroup(const std::vector<std::string>& name, @@ -2325,8 +2297,8 @@ void cmMakefile::ExpandVariablesCMP0019() l != this->Targets.end(); ++l) { cmTarget &t = l->second; - if (t.GetType() == cmTarget::INTERFACE_LIBRARY - || t.GetType() == cmTarget::GLOBAL_TARGET) + if (t.GetType() == cmState::INTERFACE_LIBRARY + || t.GetType() == cmState::GLOBAL_TARGET) { continue; } @@ -2433,10 +2405,23 @@ bool cmMakefile::PlatformIsAppleIos() const sdkRoot = this->GetSafeDefinition("CMAKE_OSX_SYSROOT"); sdkRoot = cmSystemTools::LowerCase(sdkRoot); - return sdkRoot.find("iphoneos") == 0 || - sdkRoot.find("/iphoneos") != std::string::npos || - sdkRoot.find("iphonesimulator") == 0 || - sdkRoot.find("/iphonesimulator") != std::string::npos; + const std::string embedded[] = + { + "appletvos", "appletvsimulator", + "iphoneos", "iphonesimulator", + "watchos", "watchsimulator", + }; + + for(size_t i = 0; i < sizeof(embedded) / sizeof(embedded[0]); ++i) + { + if(sdkRoot.find(embedded[i]) == 0 || + sdkRoot.find(std::string("/") + embedded[i]) != std::string::npos) + { + return true; + } + } + + return false; } const char* cmMakefile::GetSONameFlag(const std::string& language) const @@ -3163,58 +3148,6 @@ void cmMakefile::RemoveVariablesInString(std::string& source, } } -/** - * Add the default definitions to the makefile. These values must not - * be dependent on anything that isn't known when this cmMakefile instance - * is constructed. - */ -void cmMakefile::AddDefaultDefinitions() -{ -/* Up to CMake 2.4 here only WIN32, UNIX and APPLE were set. - With CMake must separate between target and host platform. In most cases - the tests for WIN32, UNIX and APPLE will be for the target system, so an - additional set of variables for the host system is required -> - CMAKE_HOST_WIN32, CMAKE_HOST_UNIX, CMAKE_HOST_APPLE. - WIN32, UNIX and APPLE are now set in the platform files in - Modules/Platforms/. - To keep cmake scripts (-P) and custom language and compiler modules - working, these variables are still also set here in this place, but they - will be reset in CMakeSystemSpecificInformation.cmake before the platform - files are executed. */ -#if defined(_WIN32) - this->AddDefinition("WIN32", "1"); - this->AddDefinition("CMAKE_HOST_WIN32", "1"); -#else - this->AddDefinition("UNIX", "1"); - this->AddDefinition("CMAKE_HOST_UNIX", "1"); -#endif -#if defined(__CYGWIN__) - if(cmSystemTools::IsOn(cmSystemTools::GetEnv("CMAKE_LEGACY_CYGWIN_WIN32"))) - { - this->AddDefinition("WIN32", "1"); - this->AddDefinition("CMAKE_HOST_WIN32", "1"); - } -#endif -#if defined(__APPLE__) - this->AddDefinition("APPLE", "1"); - this->AddDefinition("CMAKE_HOST_APPLE", "1"); -#endif - - char temp[1024]; - sprintf(temp, "%d", cmVersion::GetMinorVersion()); - this->AddDefinition("CMAKE_MINOR_VERSION", temp); - sprintf(temp, "%d", cmVersion::GetMajorVersion()); - this->AddDefinition("CMAKE_MAJOR_VERSION", temp); - sprintf(temp, "%d", cmVersion::GetPatchVersion()); - this->AddDefinition("CMAKE_PATCH_VERSION", temp); - sprintf(temp, "%d", cmVersion::GetTweakVersion()); - this->AddDefinition("CMAKE_TWEAK_VERSION", temp); - this->AddDefinition("CMAKE_VERSION", cmVersion::GetCMakeVersion()); - - this->AddDefinition("CMAKE_FILES_DIRECTORY", - cmake::GetCMakeFilesDirectory()); -} - //---------------------------------------------------------------------------- std::string cmMakefile::GetConfigurations(std::vector<std::string>& configs, @@ -4104,10 +4037,12 @@ cmTarget* cmMakefile::FindTarget(const std::string& name, { if (!excludeAliases) { - TargetMap::const_iterator i = this->AliasTargets.find(name); + std::map<std::string, std::string>::const_iterator i = + this->AliasTargets.find(name); if (i != this->AliasTargets.end()) { - return i->second; + cmTargets::iterator ai = this->Targets.find(i->second); + return &ai->second; } } cmTargets::iterator i = this->Targets.find( name ); @@ -4254,21 +4189,17 @@ void cmMakefile::RaiseScope(const std::string& var, const char *varDef) //---------------------------------------------------------------------------- cmTarget* cmMakefile::AddImportedTarget(const std::string& name, - cmTarget::TargetType type, + cmState::TargetType type, bool global) { // Create the target. cmsys::auto_ptr<cmTarget> target(new cmTarget); target->SetType(type, name); - target->MarkAsImported(); + target->MarkAsImported(global); target->SetMakefile(this); // Add to the set of available imported targets. this->ImportedTargets[name] = target.get(); - if(global) - { - this->GetGlobalGenerator()->AddTarget(target.get()); - } // Transfer ownership to this cmMakefile object. this->ImportedTargetsOwned.push_back(target.get()); @@ -4307,17 +4238,6 @@ bool cmMakefile::IsAlias(const std::string& name) const } //---------------------------------------------------------------------------- -cmGeneratorTarget* -cmMakefile::FindGeneratorTargetToUse(const std::string& name) const -{ - if (cmTarget *t = this->FindTargetToUse(name)) - { - return this->GetGlobalGenerator()->GetGeneratorTarget(t); - } - return 0; -} - -//---------------------------------------------------------------------------- bool cmMakefile::EnforceUniqueName(std::string const& name, std::string& msg, bool isCustom) const { @@ -4366,7 +4286,7 @@ bool cmMakefile::EnforceUniqueName(std::string const& name, std::string& msg, // The conflict is with a non-imported target. // Allow this if the user has requested support. cmake* cm = this->GetCMakeInstance(); - if(isCustom && existing->GetType() == cmTarget::UTILITY && + if(isCustom && existing->GetType() == cmState::UTILITY && this != existing->GetMakefile() && cm->GetState() ->GetGlobalPropertyAsBool("ALLOW_DUPLICATE_CUSTOM_TARGETS")) @@ -4382,22 +4302,22 @@ bool cmMakefile::EnforceUniqueName(std::string const& name, std::string& msg, << "The existing target is "; switch(existing->GetType()) { - case cmTarget::EXECUTABLE: + case cmState::EXECUTABLE: e << "an executable "; break; - case cmTarget::STATIC_LIBRARY: + case cmState::STATIC_LIBRARY: e << "a static library "; break; - case cmTarget::SHARED_LIBRARY: + case cmState::SHARED_LIBRARY: e << "a shared library "; break; - case cmTarget::MODULE_LIBRARY: + case cmState::MODULE_LIBRARY: e << "a module library "; break; - case cmTarget::UTILITY: + case cmState::UTILITY: e << "a custom target "; break; - case cmTarget::INTERFACE_LIBRARY: + case cmState::INTERFACE_LIBRARY: e << "an interface library "; break; default: break; diff --git a/Source/cmMakefile.h b/Source/cmMakefile.h index 1edffdc..fa1534d 100644 --- a/Source/cmMakefile.h +++ b/Source/cmMakefile.h @@ -17,7 +17,6 @@ #include "cmSystemTools.h" #include "cmTarget.h" #include "cmNewLineStyle.h" -#include "cmGeneratorTarget.h" #include "cmExpandedCommandArgument.h" #include "cmake.h" #include "cmState.h" @@ -42,7 +41,6 @@ class cmFunctionBlocker; class cmCommand; class cmInstallGenerator; -class cmMakeDepend; class cmSourceFile; class cmTest; class cmTestGenerator; @@ -51,6 +49,7 @@ class cmake; class cmMakefileCall; class cmCMakePolicyCommand; class cmGeneratorExpressionEvaluationFile; +class cmExportBuildFileGenerator; /** \class cmMakefile * \brief Process the input CMakeLists.txt file. @@ -172,10 +171,10 @@ public: /** Create a new imported target with the name and type given. */ cmTarget* AddImportedTarget(const std::string& name, - cmTarget::TargetType type, + cmState::TargetType type, bool global); - cmTarget* AddNewTarget(cmTarget::TargetType type, const std::string& name); + cmTarget* AddNewTarget(cmState::TargetType type, const std::string& name); /** * Add an executable to the build. @@ -219,9 +218,9 @@ public: * Add a link library to the build. */ void AddLinkLibrary(const std::string&); - void AddLinkLibrary(const std::string&, cmTarget::LinkLibraryType type); + void AddLinkLibrary(const std::string&, cmTargetLinkLibraryType type); void AddLinkLibraryForTarget(const std::string& tgt, const std::string&, - cmTarget::LinkLibraryType type); + cmTargetLinkLibraryType type); void AddLinkDirectoryForTarget(const std::string& tgt, const std::string& d); /** @@ -274,11 +273,6 @@ public: */ void SetProjectName(std::string const& name); - /** - * Get the name of the project for this build. - */ - std::string GetProjectName() const; - /** Get the configurations to be generated. */ std::string GetConfigurations(std::vector<std::string>& configs, bool single = true) const; @@ -286,10 +280,10 @@ public: /** * Set the name of the library. */ - cmTarget* AddLibrary(const std::string& libname, cmTarget::TargetType type, + cmTarget* AddLibrary(const std::string& libname, cmState::TargetType type, const std::vector<std::string> &srcs, bool excludeFromAll = false); - void AddAlias(const std::string& libname, cmTarget *tgt); + void AddAlias(const std::string& libname, const std::string& tgt); #if defined(CMAKE_BUILD_WITH_CMAKE) /** @@ -349,9 +343,7 @@ public: */ void SetArgcArgv(const std::vector<std::string>& args); - void SetCurrentSourceDirectory(const std::string& dir); const char* GetCurrentSourceDirectory() const; - void SetCurrentBinaryDirectory(const std::string& dir); const char* GetCurrentBinaryDirectory() const; //@} @@ -394,17 +386,7 @@ public: { return this->ImportedTargetsOwned; } - - const cmGeneratorTargetsType &GetGeneratorTargets() const - { - return this->GeneratorTargets; - } - - void SetGeneratorTargets(const cmGeneratorTargetsType &targets) - { - this->GeneratorTargets = targets; - } - void AddGeneratorTarget(cmTarget* t, cmGeneratorTarget* gt); + std::vector<cmTarget*> GetImportedTargets() const; cmTarget* FindTarget(const std::string& name, bool excludeAliases = false) const; @@ -414,7 +396,11 @@ public: cmTarget* FindTargetToUse(const std::string& name, bool excludeAliases = false) const; bool IsAlias(const std::string& name) const; - cmGeneratorTarget* FindGeneratorTargetToUse(const std::string& name) const; + + std::map<std::string, std::string> GetAliasTargets() const + { + return this->AliasTargets; + } /** * Mark include directories as system directories. @@ -441,17 +427,6 @@ public: cmSourceFile* GetOrCreateSource(const std::string& sourceName, bool generated = false); - //@{ - /** - * Return a list of extensions associated with source and header - * files - */ - const std::vector<std::string>& GetSourceExtensions() const - {return this->SourceFileExtensions;} - const std::vector<std::string>& GetHeaderExtensions() const - {return this->HeaderFileExtensions;} - //@} - /** * Given a variable name, return its value (as a string). * If the variable is not found in this makefile instance, the @@ -792,6 +767,11 @@ public: bool inputIsContent); std::vector<cmGeneratorExpressionEvaluationFile*> GetEvaluationFiles() const; + std::vector<cmExportBuildFileGenerator*> + GetExportBuildFileGenerators() const; + void RemoveExportBuildFileGeneratorCMP0024(cmExportBuildFileGenerator* gen); + void AddExportBuildFileGenerator(cmExportBuildFileGenerator* gen); + protected: // add link libraries and directories to the target void AddGlobalLinkInformation(const std::string& name, cmTarget& target); @@ -812,8 +792,7 @@ protected: #else typedef std::map<std::string, cmTarget*> TargetMap; #endif - TargetMap AliasTargets; - cmGeneratorTargetsType GeneratorTargets; + std::map<std::string, std::string> AliasTargets; std::vector<cmSourceFile*> SourceFiles; // Tests @@ -835,8 +814,6 @@ protected: std::vector<cmTestGenerator*> TestGenerators; std::string ComplainFileRegularExpression; - std::vector<std::string> SourceFileExtensions; - std::vector<std::string> HeaderFileExtensions; std::string DefineFlags; // Track the value of the computed DEFINITIONS property. @@ -867,10 +844,6 @@ private: bool EnforceUniqueDir(const std::string& srcPath, const std::string& binPath) const; - friend class cmMakeDepend; // make depend needs direct access - // to the Sources array - - void AddDefaultDefinitions(); typedef std::vector<cmFunctionBlocker*> FunctionBlockersType; FunctionBlockersType FunctionBlockers; std::vector<FunctionBlockersType::size_type> FunctionBlockerBarriers; @@ -885,6 +858,7 @@ private: mutable cmsys::RegularExpression cmNamedCurly; std::vector<cmMakefile*> UnConfiguredDirectories; + std::vector<cmExportBuildFileGenerator*> ExportBuildFileGenerators; std::vector<cmGeneratorExpressionEvaluationFile*> EvaluationFiles; diff --git a/Source/cmMakefileExecutableTargetGenerator.cxx b/Source/cmMakefileExecutableTargetGenerator.cxx index 90f679e..9e35e4c 100644 --- a/Source/cmMakefileExecutableTargetGenerator.cxx +++ b/Source/cmMakefileExecutableTargetGenerator.cxx @@ -16,7 +16,6 @@ #include "cmLocalUnixMakefileGenerator3.h" #include "cmMakefile.h" #include "cmSourceFile.h" -#include "cmTarget.h" #include "cmake.h" //---------------------------------------------------------------------------- @@ -99,8 +98,8 @@ void cmMakefileExecutableTargetGenerator::WriteExecutableRule(bool relink) this->ConfigName); // Construct the full path version of the names. - std::string outpath = this->Target->GetDirectory(this->ConfigName); - if(this->Target->IsAppBundleOnApple()) + std::string outpath = this->GeneratorTarget->GetDirectory(this->ConfigName); + if(this->GeneratorTarget->IsAppBundleOnApple()) { this->OSXBundleGenerator->CreateAppBundle(targetName, outpath); } @@ -123,7 +122,7 @@ void cmMakefileExecutableTargetGenerator::WriteExecutableRule(bool relink) cmSystemTools::MakeDirectory(outpath.c_str()); if(!targetNameImport.empty()) { - outpathImp = this->Target->GetDirectory(this->ConfigName, true); + outpathImp = this->GeneratorTarget->GetDirectory(this->ConfigName, true); cmSystemTools::MakeDirectory(outpathImp.c_str()); outpathImp += "/"; } @@ -133,7 +132,8 @@ void cmMakefileExecutableTargetGenerator::WriteExecutableRule(bool relink) this->GeneratorTarget->GetCompilePDBDirectory(this->ConfigName); cmSystemTools::MakeDirectory(compilePdbOutputPath.c_str()); - std::string pdbOutputPath = this->Target->GetPDBDirectory(this->ConfigName); + std::string pdbOutputPath = + this->GeneratorTarget->GetPDBDirectory(this->ConfigName); cmSystemTools::MakeDirectory(pdbOutputPath.c_str()); pdbOutputPath += "/"; @@ -167,7 +167,7 @@ void cmMakefileExecutableTargetGenerator::WriteExecutableRule(bool relink) if(linkLanguage.empty()) { cmSystemTools::Error("Cannot determine link language for target \"", - this->Target->GetName().c_str(), "\"."); + this->GeneratorTarget->GetName().c_str(), "\"."); return; } @@ -196,7 +196,7 @@ void cmMakefileExecutableTargetGenerator::WriteExecutableRule(bool relink) this->ConfigName); - if(this->Target->GetPropertyAsBool("WIN32_EXECUTABLE")) + if(this->GeneratorTarget->GetPropertyAsBool("WIN32_EXECUTABLE")) { this->LocalGenerator->AppendFlags (linkFlags, this->Makefile->GetDefinition("CMAKE_CREATE_WIN32_EXE")); @@ -208,7 +208,7 @@ void cmMakefileExecutableTargetGenerator::WriteExecutableRule(bool relink) } // Add symbol export flags if necessary. - if(this->Target->IsExecutableWithExports()) + if(this->GeneratorTarget->IsExecutableWithExports()) { std::string export_flag_var = "CMAKE_EXE_EXPORTS_"; export_flag_var += linkLanguage; @@ -225,11 +225,11 @@ void cmMakefileExecutableTargetGenerator::WriteExecutableRule(bool relink) // Add target-specific linker flags. this->LocalGenerator->AppendFlags - (linkFlags, this->Target->GetProperty("LINK_FLAGS")); + (linkFlags, this->GeneratorTarget->GetProperty("LINK_FLAGS")); std::string linkFlagsConfig = "LINK_FLAGS_"; linkFlagsConfig += cmSystemTools::UpperCase(this->ConfigName); this->LocalGenerator->AppendFlags - (linkFlags, this->Target->GetProperty(linkFlagsConfig)); + (linkFlags, this->GeneratorTarget->GetProperty(linkFlagsConfig)); this->AddModuleDefinitionFlag(linkFlags); @@ -258,7 +258,7 @@ void cmMakefileExecutableTargetGenerator::WriteExecutableRule(bool relink) cmLocalGenerator::START_OUTPUT, cmLocalGenerator::UNCHANGED)); std::string implib; - if(this->Target->GetImplibGNUtoMS(targetFullPathImport, implib)) + if(this->GeneratorTarget->GetImplibGNUtoMS(targetFullPathImport, implib)) { exeCleanFiles.push_back(this->Convert(implib, cmLocalGenerator::START_OUTPUT, @@ -278,11 +278,13 @@ void cmMakefileExecutableTargetGenerator::WriteExecutableRule(bool relink) if(!relink) { this->LocalGenerator - ->AppendCustomCommands(commands, this->Target->GetPreBuildCommands(), - this->Target); + ->AppendCustomCommands(commands, + this->GeneratorTarget->GetPreBuildCommands(), + this->GeneratorTarget); this->LocalGenerator - ->AppendCustomCommands(commands, this->Target->GetPreLinkCommands(), - this->Target); + ->AppendCustomCommands(commands, + this->GeneratorTarget->GetPreLinkCommands(), + this->GeneratorTarget); } // Determine whether a link script will be used. @@ -296,7 +298,7 @@ void cmMakefileExecutableTargetGenerator::WriteExecutableRule(bool relink) std::string linkRule = this->GetLinkRule(linkRuleVar); std::vector<std::string> commands1; cmSystemTools::ExpandListArgument(linkRule, real_link_commands); - if(this->Target->IsExecutableWithExports()) + if(this->GeneratorTarget->IsExecutableWithExports()) { // If a separate rule for creating an import library is specified // add it now. @@ -357,10 +359,10 @@ void cmMakefileExecutableTargetGenerator::WriteExecutableRule(bool relink) cmLocalGenerator::RuleVariables vars; vars.RuleLauncher = "RULE_LAUNCH_LINK"; - vars.CMTarget = this->Target; + vars.CMTarget = this->GeneratorTarget; vars.Language = linkLanguage.c_str(); vars.Objects = buildObjs.c_str(); - std::string objectDir = this->Target->GetSupportDirectory(); + std::string objectDir = this->GeneratorTarget->GetSupportDirectory(); objectDir = this->Convert(objectDir, cmLocalGenerator::START_OUTPUT, cmLocalGenerator::SHELL); @@ -381,7 +383,7 @@ void cmMakefileExecutableTargetGenerator::WriteExecutableRule(bool relink) std::ostringstream minorStream; int major; int minor; - this->Target->GetTargetVersion(major, minor); + this->GeneratorTarget->GetTargetVersion(major, minor); majorStream << major; minorStream << minor; targetVersionMajor = majorStream.str(); @@ -447,8 +449,9 @@ void cmMakefileExecutableTargetGenerator::WriteExecutableRule(bool relink) if(!relink) { this->LocalGenerator-> - AppendCustomCommands(commands, this->Target->GetPostBuildCommands(), - this->Target); + AppendCustomCommands(commands, + this->GeneratorTarget->GetPostBuildCommands(), + this->GeneratorTarget); } // Write the build rule. diff --git a/Source/cmMakefileLibraryTargetGenerator.cxx b/Source/cmMakefileLibraryTargetGenerator.cxx index cd387a0..1923ea4 100644 --- a/Source/cmMakefileLibraryTargetGenerator.cxx +++ b/Source/cmMakefileLibraryTargetGenerator.cxx @@ -16,7 +16,6 @@ #include "cmLocalUnixMakefileGenerator3.h" #include "cmMakefile.h" #include "cmSourceFile.h" -#include "cmTarget.h" #include "cmake.h" #include "cmAlgorithms.h" @@ -26,7 +25,7 @@ cmMakefileLibraryTargetGenerator cmMakefileTargetGenerator(target) { this->CustomCommandDriver = OnDepends; - if (this->Target->GetType() != cmTarget::INTERFACE_LIBRARY) + if (this->GeneratorTarget->GetType() != cmState::INTERFACE_LIBRARY) { this->GeneratorTarget->GetLibraryNames( this->TargetNameOut, this->TargetNameSO, this->TargetNameReal, @@ -62,12 +61,12 @@ void cmMakefileLibraryTargetGenerator::WriteRuleFiles() // write the link rules // Write the rule for this target type. - switch(this->Target->GetType()) + switch(this->GeneratorTarget->GetType()) { - case cmTarget::STATIC_LIBRARY: + case cmState::STATIC_LIBRARY: this->WriteStaticLibraryRules(); break; - case cmTarget::SHARED_LIBRARY: + case cmState::SHARED_LIBRARY: this->WriteSharedLibraryRules(false); if(this->GeneratorTarget->NeedRelinkBeforeInstall(this->ConfigName)) { @@ -75,7 +74,7 @@ void cmMakefileLibraryTargetGenerator::WriteRuleFiles() this->WriteSharedLibraryRules(true); } break; - case cmTarget::MODULE_LIBRARY: + case cmState::MODULE_LIBRARY: this->WriteModuleLibraryRules(false); if(this->GeneratorTarget->NeedRelinkBeforeInstall(this->ConfigName)) { @@ -83,7 +82,7 @@ void cmMakefileLibraryTargetGenerator::WriteRuleFiles() this->WriteModuleLibraryRules(true); } break; - case cmTarget::OBJECT_LIBRARY: + case cmState::OBJECT_LIBRARY: this->WriteObjectLibraryRules(); break; default: @@ -114,19 +113,20 @@ void cmMakefileLibraryTargetGenerator::WriteObjectLibraryRules() // Add post-build rules. this->LocalGenerator-> - AppendCustomCommands(commands, this->Target->GetPostBuildCommands(), - this->Target); + AppendCustomCommands(commands, + this->GeneratorTarget->GetPostBuildCommands(), + this->GeneratorTarget); // Depend on the object files. this->AppendObjectDepends(depends); // Write the rule. this->LocalGenerator->WriteMakeRule(*this->BuildFileStream, 0, - this->Target->GetName(), + this->GeneratorTarget->GetName(), depends, commands, true); // Write the main driver rule to build everything in this target. - this->WriteTargetDriverRule(this->Target->GetName(), false); + this->WriteTargetDriverRule(this->GeneratorTarget->GetName(), false); } //---------------------------------------------------------------------------- @@ -146,14 +146,14 @@ void cmMakefileLibraryTargetGenerator::WriteStaticLibraryRules() std::string extraFlags; this->LocalGenerator->GetStaticLibraryFlags(extraFlags, - cmSystemTools::UpperCase(this->ConfigName), this->Target); + cmSystemTools::UpperCase(this->ConfigName), this->GeneratorTarget); this->WriteLibraryRules(linkRuleVar, extraFlags, false); } //---------------------------------------------------------------------------- void cmMakefileLibraryTargetGenerator::WriteSharedLibraryRules(bool relink) { - if(this->Target->IsFrameworkOnApple()) + if(this->GeneratorTarget->IsFrameworkOnApple()) { this->WriteFrameworkRules(relink); return; @@ -166,11 +166,11 @@ void cmMakefileLibraryTargetGenerator::WriteSharedLibraryRules(bool relink) std::string extraFlags; this->LocalGenerator->AppendFlags - (extraFlags, this->Target->GetProperty("LINK_FLAGS")); + (extraFlags, this->GeneratorTarget->GetProperty("LINK_FLAGS")); std::string linkFlagsConfig = "LINK_FLAGS_"; linkFlagsConfig += cmSystemTools::UpperCase(this->ConfigName); this->LocalGenerator->AppendFlags - (extraFlags, this->Target->GetProperty(linkFlagsConfig)); + (extraFlags, this->GeneratorTarget->GetProperty(linkFlagsConfig)); this->LocalGenerator->AddConfigVariableFlags (extraFlags, "CMAKE_SHARED_LINKER_FLAGS", this->ConfigName); @@ -190,11 +190,11 @@ void cmMakefileLibraryTargetGenerator::WriteModuleLibraryRules(bool relink) std::string extraFlags; this->LocalGenerator->AppendFlags(extraFlags, - this->Target->GetProperty("LINK_FLAGS")); + this->GeneratorTarget->GetProperty("LINK_FLAGS")); std::string linkFlagsConfig = "LINK_FLAGS_"; linkFlagsConfig += cmSystemTools::UpperCase(this->ConfigName); this->LocalGenerator->AppendFlags - (extraFlags, this->Target->GetProperty(linkFlagsConfig)); + (extraFlags, this->GeneratorTarget->GetProperty(linkFlagsConfig)); this->LocalGenerator->AddConfigVariableFlags (extraFlags, "CMAKE_MODULE_LINKER_FLAGS", this->ConfigName); this->AddModuleDefinitionFlag(extraFlags); @@ -213,11 +213,11 @@ void cmMakefileLibraryTargetGenerator::WriteFrameworkRules(bool relink) std::string extraFlags; this->LocalGenerator->AppendFlags(extraFlags, - this->Target->GetProperty("LINK_FLAGS")); + this->GeneratorTarget->GetProperty("LINK_FLAGS")); std::string linkFlagsConfig = "LINK_FLAGS_"; linkFlagsConfig += cmSystemTools::UpperCase(this->ConfigName); this->LocalGenerator->AppendFlags - (extraFlags, this->Target->GetProperty(linkFlagsConfig)); + (extraFlags, this->GeneratorTarget->GetProperty(linkFlagsConfig)); this->LocalGenerator->AddConfigVariableFlags (extraFlags, "CMAKE_MACOSX_FRAMEWORK_LINKER_FLAGS", this->ConfigName); @@ -244,7 +244,7 @@ void cmMakefileLibraryTargetGenerator::WriteLibraryRules if(linkLanguage.empty()) { cmSystemTools::Error("Cannot determine link language for target \"", - this->Target->GetName().c_str(), "\"."); + this->GeneratorTarget->GetName().c_str(), "\"."); return; } @@ -253,8 +253,8 @@ void cmMakefileLibraryTargetGenerator::WriteLibraryRules this->LocalGenerator->AppendFlags(linkFlags, extraFlags); // Add OSX version flags, if any. - if(this->Target->GetType() == cmTarget::SHARED_LIBRARY || - this->Target->GetType() == cmTarget::MODULE_LIBRARY) + if(this->GeneratorTarget->GetType() == cmState::SHARED_LIBRARY || + this->GeneratorTarget->GetType() == cmState::MODULE_LIBRARY) { this->AppendOSXVerFlag(linkFlags, linkLanguage, "COMPATIBILITY", true); this->AppendOSXVerFlag(linkFlags, linkLanguage, "CURRENT", false); @@ -273,15 +273,15 @@ void cmMakefileLibraryTargetGenerator::WriteLibraryRules // Construct the full path version of the names. std::string outpath; std::string outpathImp; - if(this->Target->IsFrameworkOnApple()) + if(this->GeneratorTarget->IsFrameworkOnApple()) { - outpath = this->Target->GetDirectory(this->ConfigName); + outpath = this->GeneratorTarget->GetDirectory(this->ConfigName); this->OSXBundleGenerator->CreateFramework(targetName, outpath); outpath += "/"; } - else if(this->Target->IsCFBundleOnApple()) + else if(this->GeneratorTarget->IsCFBundleOnApple()) { - outpath = this->Target->GetDirectory(this->ConfigName); + outpath = this->GeneratorTarget->GetDirectory(this->ConfigName); this->OSXBundleGenerator->CreateCFBundle(targetName, outpath); outpath += "/"; } @@ -299,12 +299,12 @@ void cmMakefileLibraryTargetGenerator::WriteLibraryRules } else { - outpath = this->Target->GetDirectory(this->ConfigName); + outpath = this->GeneratorTarget->GetDirectory(this->ConfigName); cmSystemTools::MakeDirectory(outpath.c_str()); outpath += "/"; if(!targetNameImport.empty()) { - outpathImp = this->Target->GetDirectory(this->ConfigName, true); + outpathImp = this->GeneratorTarget->GetDirectory(this->ConfigName, true); cmSystemTools::MakeDirectory(outpathImp.c_str()); outpathImp += "/"; } @@ -314,7 +314,8 @@ void cmMakefileLibraryTargetGenerator::WriteLibraryRules this->GeneratorTarget->GetCompilePDBDirectory(this->ConfigName); cmSystemTools::MakeDirectory(compilePdbOutputPath.c_str()); - std::string pdbOutputPath = this->Target->GetPDBDirectory(this->ConfigName); + std::string pdbOutputPath = + this->GeneratorTarget->GetPDBDirectory(this->ConfigName); cmSystemTools::MakeDirectory(pdbOutputPath.c_str()); pdbOutputPath += "/"; @@ -350,16 +351,16 @@ void cmMakefileLibraryTargetGenerator::WriteLibraryRules // Add the link message. std::string buildEcho = "Linking "; buildEcho += linkLanguage; - switch(this->Target->GetType()) + switch(this->GeneratorTarget->GetType()) { - case cmTarget::STATIC_LIBRARY: + case cmState::STATIC_LIBRARY: buildEcho += " static library "; break; - case cmTarget::SHARED_LIBRARY: + case cmState::SHARED_LIBRARY: buildEcho += " shared library "; break; - case cmTarget::MODULE_LIBRARY: - if (this->Target->IsCFBundleOnApple()) + case cmState::MODULE_LIBRARY: + if (this->GeneratorTarget->IsCFBundleOnApple()) buildEcho += " CFBundle"; buildEcho += " shared module "; break; @@ -374,12 +375,12 @@ void cmMakefileLibraryTargetGenerator::WriteLibraryRules } const char* forbiddenFlagVar = 0; - switch(this->Target->GetType()) + switch(this->GeneratorTarget->GetType()) { - case cmTarget::SHARED_LIBRARY: + case cmState::SHARED_LIBRARY: forbiddenFlagVar = "_CREATE_SHARED_LIBRARY_FORBIDDEN_FLAGS"; break; - case cmTarget::MODULE_LIBRARY: + case cmState::MODULE_LIBRARY: forbiddenFlagVar = "_CREATE_SHARED_MODULE_FORBIDDEN_FLAGS"; break; default: break; @@ -409,7 +410,7 @@ void cmMakefileLibraryTargetGenerator::WriteLibraryRules cmLocalGenerator::START_OUTPUT, cmLocalGenerator::UNCHANGED)); std::string implib; - if(this->Target->GetImplibGNUtoMS(targetFullPathImport, implib)) + if(this->GeneratorTarget->GetImplibGNUtoMS(targetFullPathImport, implib)) { libCleanFiles.push_back(this->Convert(implib, cmLocalGenerator::START_OUTPUT, @@ -428,7 +429,7 @@ void cmMakefileLibraryTargetGenerator::WriteLibraryRules #ifdef _WIN32 // There may be a manifest file for this target. Add it to the // clean set just in case. - if(this->Target->GetType() != cmTarget::STATIC_LIBRARY) + if(this->GeneratorTarget->GetType() != cmState::STATIC_LIBRARY) { libCleanFiles.push_back( this->Convert((targetFullPath+".manifest").c_str(), @@ -440,10 +441,10 @@ void cmMakefileLibraryTargetGenerator::WriteLibraryRules std::vector<std::string> commands1; // Add a command to remove any existing files for this library. // for static libs only - if(this->Target->GetType() == cmTarget::STATIC_LIBRARY) + if(this->GeneratorTarget->GetType() == cmState::STATIC_LIBRARY) { this->LocalGenerator->AppendCleanCommand(commands1, libCleanFiles, - *this->Target, "target"); + this->GeneratorTarget, "target"); this->LocalGenerator->CreateCDCommand (commands1, this->Makefile->GetCurrentBinaryDirectory(), @@ -456,11 +457,13 @@ void cmMakefileLibraryTargetGenerator::WriteLibraryRules if(!relink) { this->LocalGenerator - ->AppendCustomCommands(commands, this->Target->GetPreBuildCommands(), - this->Target); + ->AppendCustomCommands(commands, + this->GeneratorTarget->GetPreBuildCommands(), + this->GeneratorTarget); this->LocalGenerator - ->AppendCustomCommands(commands, this->Target->GetPreLinkCommands(), - this->Target); + ->AppendCustomCommands(commands, + this->GeneratorTarget->GetPreLinkCommands(), + this->GeneratorTarget); } // Determine whether a link script will be used. @@ -496,7 +499,7 @@ void cmMakefileLibraryTargetGenerator::WriteLibraryRules std::vector<std::string> archiveAppendCommands; std::vector<std::string> archiveFinishCommands; std::string::size_type archiveCommandLimit = std::string::npos; - if(this->Target->GetType() == cmTarget::STATIC_LIBRARY) + if(this->GeneratorTarget->GetType() == cmState::STATIC_LIBRARY) { haveStaticLibraryRule = this->Makefile->GetDefinition(linkRuleVar)? true:false; @@ -551,7 +554,7 @@ void cmMakefileLibraryTargetGenerator::WriteLibraryRules // Collect up flags to link in needed libraries. std::string linkLibs; - if(this->Target->GetType() != cmTarget::STATIC_LIBRARY) + if(this->GeneratorTarget->GetType() != cmState::STATIC_LIBRARY) { this->CreateLinkLibs(linkLibs, relink, useResponseFileForLibs, depends, useWatcomQuote); @@ -565,15 +568,15 @@ void cmMakefileLibraryTargetGenerator::WriteLibraryRules useWatcomQuote); // maybe create .def file from list of objects - if (this->Target->GetType() == cmTarget::SHARED_LIBRARY && + if (this->GeneratorTarget->GetType() == cmState::SHARED_LIBRARY && this->Makefile->IsOn("CMAKE_SUPPORT_WINDOWS_EXPORT_ALL_SYMBOLS")) { - if(this->Target->GetPropertyAsBool("WINDOWS_EXPORT_ALL_SYMBOLS")) + if(this->GeneratorTarget->GetPropertyAsBool("WINDOWS_EXPORT_ALL_SYMBOLS")) { std::string name_of_def_file = - this->Target->GetSupportDirectory(); + this->GeneratorTarget->GetSupportDirectory(); name_of_def_file += std::string("/") + - this->Target->GetName(); + this->GeneratorTarget->GetName(); name_of_def_file += ".def"; std::string cmd = cmSystemTools::GetCMakeCommand(); cmd = this->Convert(cmd, cmLocalGenerator::NONE, @@ -629,7 +632,7 @@ void cmMakefileLibraryTargetGenerator::WriteLibraryRules std::ostringstream minorStream; int major; int minor; - this->Target->GetTargetVersion(major, minor); + this->GeneratorTarget->GetTargetVersion(major, minor); majorStream << major; minorStream << minor; targetVersionMajor = majorStream.str(); @@ -639,10 +642,10 @@ void cmMakefileLibraryTargetGenerator::WriteLibraryRules vars.TargetVersionMinor = targetVersionMinor.c_str(); vars.RuleLauncher = "RULE_LAUNCH_LINK"; - vars.CMTarget = this->Target; + vars.CMTarget = this->GeneratorTarget; vars.Language = linkLanguage.c_str(); vars.Objects = buildObjs.c_str(); - std::string objectDir = this->Target->GetSupportDirectory(); + std::string objectDir = this->GeneratorTarget->GetSupportDirectory(); objectDir = this->Convert(objectDir, cmLocalGenerator::START_OUTPUT, cmLocalGenerator::SHELL); @@ -666,7 +669,7 @@ void cmMakefileLibraryTargetGenerator::WriteLibraryRules // Compute the directory portion of the install_name setting. std::string install_name_dir; - if(this->Target->GetType() == cmTarget::SHARED_LIBRARY) + if(this->GeneratorTarget->GetType() == cmState::SHARED_LIBRARY) { // Get the install_name directory for the build tree. install_name_dir = @@ -790,7 +793,8 @@ void cmMakefileLibraryTargetGenerator::WriteLibraryRules // Add a rule to create necessary symlinks for the library. // Frameworks are handled by cmOSXBundleGenerator. - if(targetOutPath != targetOutPathReal && !this->Target->IsFrameworkOnApple()) + if(targetOutPath != targetOutPathReal + && !this->GeneratorTarget->IsFrameworkOnApple()) { std::string symlink = "$(CMAKE_COMMAND) -E cmake_symlink_library "; symlink += targetOutPathReal; @@ -809,8 +813,9 @@ void cmMakefileLibraryTargetGenerator::WriteLibraryRules if(!relink) { this->LocalGenerator-> - AppendCustomCommands(commands, this->Target->GetPostBuildCommands(), - this->Target); + AppendCustomCommands(commands, + this->GeneratorTarget->GetPostBuildCommands(), + this->GeneratorTarget); } // Compute the list of outputs. @@ -861,7 +866,7 @@ cmMakefileLibraryTargetGenerator int major; int minor; int patch; - this->Target->GetTargetVersion(so, major, minor, patch); + this->GeneratorTarget->GetTargetVersion(so, major, minor, patch); if(major > 0 || minor > 0 || patch > 0) { // Append the flag since a non-zero version is specified. diff --git a/Source/cmMakefileTargetGenerator.cxx b/Source/cmMakefileTargetGenerator.cxx index b278087..eedc6ab 100644 --- a/Source/cmMakefileTargetGenerator.cxx +++ b/Source/cmMakefileTargetGenerator.cxx @@ -18,7 +18,6 @@ #include "cmLocalUnixMakefileGenerator3.h" #include "cmMakefile.h" #include "cmSourceFile.h" -#include "cmTarget.h" #include "cmake.h" #include "cmState.h" #include "cmComputeLinkInformation.h" @@ -68,16 +67,16 @@ cmMakefileTargetGenerator::New(cmGeneratorTarget *tgt) switch (tgt->GetType()) { - case cmTarget::EXECUTABLE: + case cmState::EXECUTABLE: result = new cmMakefileExecutableTargetGenerator(tgt); break; - case cmTarget::STATIC_LIBRARY: - case cmTarget::SHARED_LIBRARY: - case cmTarget::MODULE_LIBRARY: - case cmTarget::OBJECT_LIBRARY: + case cmState::STATIC_LIBRARY: + case cmState::SHARED_LIBRARY: + case cmState::MODULE_LIBRARY: + case cmState::OBJECT_LIBRARY: result = new cmMakefileLibraryTargetGenerator(tgt); break; - case cmTarget::UTILITY: + case cmState::UTILITY: result = new cmMakefileUtilityTargetGenerator(tgt); break; default: @@ -92,7 +91,7 @@ void cmMakefileTargetGenerator::CreateRuleFile() { // Create a directory for this target. this->TargetBuildDirectory = - this->LocalGenerator->GetTargetDirectory(*this->Target); + this->LocalGenerator->GetTargetDirectory(this->GeneratorTarget); this->TargetBuildDirectoryFull = this->LocalGenerator->ConvertToFullPath(this->TargetBuildDirectory); cmSystemTools::MakeDirectory(this->TargetBuildDirectoryFull.c_str()); @@ -147,8 +146,11 @@ void cmMakefileTargetGenerator::WriteTargetBuildRules() cmsys::auto_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(additional_clean_files); - cmSystemTools::ExpandListArgument(cge->Evaluate(this->Makefile, config, - false, this->Target, 0, 0), + cmSystemTools::ExpandListArgument(cge->Evaluate(this->LocalGenerator, + config, + false, + this->GeneratorTarget, + 0, 0), this->CleanFiles); } @@ -245,7 +247,8 @@ void cmMakefileTargetGenerator::WriteCommonCodeRules() // Write an empty dependency file. cmGeneratedFileStream depFileStream(dependFileNameFull.c_str()); depFileStream - << "# Empty dependencies file for " << this->Target->GetName() << ".\n" + << "# Empty dependencies file for " + << this->GeneratorTarget->GetName() << ".\n" << "# This may be replaced when dependencies are built." << std::endl; } @@ -375,7 +378,8 @@ void cmMakefileTargetGenerator // Get the full path name of the object file. std::string const& objectName = this->GeneratorTarget ->GetObjectName(&source); - std::string obj = this->LocalGenerator->GetTargetDirectory(*this->Target); + std::string obj = + this->LocalGenerator->GetTargetDirectory(this->GeneratorTarget); obj += "/"; obj += objectName; @@ -390,7 +394,7 @@ void cmMakefileTargetGenerator err << "Warning: Source file \"" << source.GetFullPath() << "\" is listed multiple times for target \"" - << this->Target->GetName() + << this->GeneratorTarget->GetName() << "\"."; cmSystemTools::Message(err.str().c_str(), "Warning"); return; @@ -419,7 +423,7 @@ void cmMakefileTargetGenerator this->WriteObjectBuildFile(obj, lang, source, depends); // The object file should be checked for dependency integrity. - std::string objFullPath = this->Makefile->GetCurrentBinaryDirectory(); + std::string objFullPath = this->LocalGenerator->GetCurrentBinaryDirectory(); objFullPath += "/"; objFullPath += obj; objFullPath = @@ -427,7 +431,7 @@ void cmMakefileTargetGenerator std::string srcFullPath = this->Convert(source.GetFullPath(), cmLocalGenerator::FULL); this->LocalGenerator-> - AddImplicitDepends(*this->Target, lang, + AddImplicitDepends(this->GeneratorTarget, lang, objFullPath.c_str(), srcFullPath.c_str()); } @@ -539,24 +543,26 @@ cmMakefileTargetGenerator std::string targetFullPathReal; std::string targetFullPathPDB; std::string targetFullPathCompilePDB; - if(this->Target->GetType() == cmTarget::EXECUTABLE || - this->Target->GetType() == cmTarget::STATIC_LIBRARY || - this->Target->GetType() == cmTarget::SHARED_LIBRARY || - this->Target->GetType() == cmTarget::MODULE_LIBRARY) + if(this->GeneratorTarget->GetType() == cmState::EXECUTABLE || + this->GeneratorTarget->GetType() == cmState::STATIC_LIBRARY || + this->GeneratorTarget->GetType() == cmState::SHARED_LIBRARY || + this->GeneratorTarget->GetType() == cmState::MODULE_LIBRARY) { targetFullPathReal = this->GeneratorTarget->GetFullPath(this->ConfigName, false, true); - targetFullPathPDB = this->Target->GetPDBDirectory(this->ConfigName); + targetFullPathPDB = + this->GeneratorTarget->GetPDBDirectory(this->ConfigName); targetFullPathPDB += "/"; targetFullPathPDB += this->GeneratorTarget->GetPDBName(this->ConfigName); } - if(this->Target->GetType() <= cmTarget::OBJECT_LIBRARY) + if(this->GeneratorTarget->GetType() <= cmState::OBJECT_LIBRARY) { targetFullPathCompilePDB = this->GeneratorTarget->GetCompilePDBPath(this->ConfigName); if(targetFullPathCompilePDB.empty()) { - targetFullPathCompilePDB = this->Target->GetSupportDirectory() + "/"; + targetFullPathCompilePDB = + this->GeneratorTarget->GetSupportDirectory() + "/"; } } @@ -582,7 +588,7 @@ cmMakefileTargetGenerator } cmLocalGenerator::RuleVariables vars; vars.RuleLauncher = "RULE_LAUNCH_COMPILE"; - vars.CMTarget = this->Target; + vars.CMTarget = this->GeneratorTarget; vars.Language = lang.c_str(); vars.Target = targetOutPathReal.c_str(); vars.TargetPDB = targetOutPathPDB.c_str(); @@ -593,7 +599,7 @@ cmMakefileTargetGenerator cmLocalGenerator::NONE, cmLocalGenerator::SHELL); vars.Object = shellObj.c_str(); - std::string objectDir = this->Target->GetSupportDirectory(); + std::string objectDir = this->GeneratorTarget->GetSupportDirectory(); objectDir = this->Convert(objectDir, cmLocalGenerator::START_OUTPUT, cmLocalGenerator::SHELL); @@ -642,7 +648,8 @@ cmMakefileTargetGenerator this->LocalGenerator->ExpandRuleVariables(compileCommand, vars); std::string workingDirectory = this->LocalGenerator->Convert( - this->Makefile->GetCurrentBinaryDirectory(), cmLocalGenerator::FULL); + this->LocalGenerator->GetCurrentBinaryDirectory(), + cmLocalGenerator::FULL); compileCommand.replace(compileCommand.find(langFlags), langFlags.size(), this->GetFlags(lang)); std::string langDefines = std::string("$(") + lang + "_DEFINES)"; @@ -659,7 +666,7 @@ cmMakefileTargetGenerator if (!compileCommands.empty() && (lang == "C" || lang == "CXX")) { std::string const iwyu_prop = lang + "_INCLUDE_WHAT_YOU_USE"; - const char *iwyu = this->Target->GetProperty(iwyu_prop); + const char *iwyu = this->GeneratorTarget->GetProperty(iwyu_prop); if (iwyu && *iwyu) { std::string run_iwyu = "$(CMAKE_COMMAND) -E __run_iwyu --iwyu="; @@ -673,7 +680,7 @@ cmMakefileTargetGenerator if (!compileCommands.empty() && (lang == "C" || lang == "CXX")) { std::string const clauncher_prop = lang + "_COMPILER_LAUNCHER"; - const char *clauncher = this->Target->GetProperty(clauncher_prop); + const char *clauncher = this->GeneratorTarget->GetProperty(clauncher_prop); if (clauncher && *clauncher) { std::vector<std::string> launcher_cmd; @@ -698,7 +705,7 @@ cmMakefileTargetGenerator // Change the command working directory to the local build tree. this->LocalGenerator->CreateCDCommand (compileCommands, - this->Makefile->GetCurrentBinaryDirectory(), + this->LocalGenerator->GetCurrentBinaryDirectory(), cmLocalGenerator::HOME_OUTPUT); commands.insert(commands.end(), compileCommands.begin(), compileCommands.end()); @@ -771,7 +778,7 @@ cmMakefileTargetGenerator this->LocalGenerator->CreateCDCommand (preprocessCommands, - this->Makefile->GetCurrentBinaryDirectory(), + this->LocalGenerator->GetCurrentBinaryDirectory(), cmLocalGenerator::HOME_OUTPUT); commands.insert(commands.end(), preprocessCommands.begin(), @@ -828,7 +835,7 @@ cmMakefileTargetGenerator this->LocalGenerator->CreateCDCommand (assemblyCommands, - this->Makefile->GetCurrentBinaryDirectory(), + this->LocalGenerator->GetCurrentBinaryDirectory(), cmLocalGenerator::HOME_OUTPUT); commands.insert(commands.end(), assemblyCommands.begin(), @@ -864,7 +871,7 @@ cmMakefileTargetGenerator temp += ".provides.build"; std::vector<std::string> r_commands; std::string tgtMakefileName = - this->LocalGenerator->GetRelativeTargetDirectory(*this->Target); + this->LocalGenerator->GetRelativeTargetDirectory(this->GeneratorTarget); tgtMakefileName += "/build.make"; r_commands.push_back (this->LocalGenerator->GetRecursiveMakeCall(tgtMakefileName.c_str(), @@ -892,7 +899,7 @@ void cmMakefileTargetGenerator::WriteTargetRequiresRules() // Construct the name of the dependency generation target. std::string depTarget = - this->LocalGenerator->GetRelativeTargetDirectory(*this->Target); + this->LocalGenerator->GetRelativeTargetDirectory(this->GeneratorTarget); depTarget += "/requires"; // This target drives dependency generation for all object files. @@ -921,15 +928,15 @@ void cmMakefileTargetGenerator::WriteTargetCleanRules() // Construct the clean target name. std::string cleanTarget = - this->LocalGenerator->GetRelativeTargetDirectory(*this->Target); + this->LocalGenerator->GetRelativeTargetDirectory(this->GeneratorTarget); cleanTarget += "/clean"; // Construct the clean command. this->LocalGenerator->AppendCleanCommand(commands, this->CleanFiles, - *this->Target); + this->GeneratorTarget); this->LocalGenerator->CreateCDCommand (commands, - this->Makefile->GetCurrentBinaryDirectory(), + this->LocalGenerator->GetCurrentBinaryDirectory(), cmLocalGenerator::HOME_OUTPUT); // Write the rule. @@ -1018,7 +1025,8 @@ bool cmMakefileTargetGenerator::WriteMakeRule( void cmMakefileTargetGenerator::WriteTargetDependRules() { // must write the targets depend info file - std::string dir = this->LocalGenerator->GetTargetDirectory(*this->Target); + std::string dir = + this->LocalGenerator->GetTargetDirectory(this->GeneratorTarget); this->InfoFileNameFull = dir; this->InfoFileNameFull += "/DependInfo.cmake"; this->InfoFileNameFull = @@ -1031,7 +1039,7 @@ void cmMakefileTargetGenerator::WriteTargetDependRules() return; } this->LocalGenerator-> - WriteDependLanguageInfo(*this->InfoFileStream,*this->Target); + WriteDependLanguageInfo(*this->InfoFileStream, this->GeneratorTarget); // Store multiple output pairs in the depend info file. if(!this->MultipleOutputPairs.empty()) @@ -1080,7 +1088,7 @@ void cmMakefileTargetGenerator::WriteTargetDependRules() // Construct the name of the dependency generation target. std::string depTarget = - this->LocalGenerator->GetRelativeTargetDirectory(*this->Target); + this->LocalGenerator->GetRelativeTargetDirectory(this->GeneratorTarget); depTarget += "/depend"; // Add a command to call CMake to scan dependencies. CMake will @@ -1095,7 +1103,7 @@ void cmMakefileTargetGenerator::WriteTargetDependRules() // translation table for the dependency scanning process. depCmd << "cd " << (this->LocalGenerator->Convert( - this->Makefile->GetHomeOutputDirectory(), + this->LocalGenerator->GetBinaryDirectory(), cmLocalGenerator::FULL, cmLocalGenerator::SHELL)) << " && "; #endif @@ -1110,16 +1118,16 @@ void cmMakefileTargetGenerator::WriteTargetDependRules() // the state of our local generator sufficiently for its needs. depCmd << "$(CMAKE_COMMAND) -E cmake_depends \"" << this->GlobalGenerator->GetName() << "\" " - << this->Convert(this->Makefile->GetHomeDirectory(), + << this->Convert(this->LocalGenerator->GetSourceDirectory(), cmLocalGenerator::FULL, cmLocalGenerator::SHELL) << " " - << this->Convert(this->Makefile->GetCurrentSourceDirectory(), + << this->Convert(this->LocalGenerator->GetCurrentSourceDirectory(), cmLocalGenerator::FULL, cmLocalGenerator::SHELL) << " " - << this->Convert(this->Makefile->GetHomeOutputDirectory(), + << this->Convert(this->LocalGenerator->GetBinaryDirectory(), cmLocalGenerator::FULL, cmLocalGenerator::SHELL) << " " - << this->Convert(this->Makefile->GetCurrentBinaryDirectory(), + << this->Convert(this->LocalGenerator->GetCurrentBinaryDirectory(), cmLocalGenerator::FULL, cmLocalGenerator::SHELL) << " " << this->Convert(this->InfoFileNameFull, @@ -1149,7 +1157,7 @@ cmMakefileTargetGenerator { // Depend on all custom command outputs. std::vector<cmSourceFile*> sources; - this->Target->GetSourceFiles(sources, + this->GeneratorTarget->GetSourceFiles(sources, this->Makefile->GetSafeDefinition("CMAKE_BUILD_TYPE")); for(std::vector<cmSourceFile*>::const_iterator source = sources.begin(); source != sources.end(); ++source) @@ -1202,7 +1210,8 @@ void cmMakefileTargetGenerator // Now append the actual user-specified commands. std::ostringstream content; - this->LocalGenerator->AppendCustomCommand(commands, ccg, this->Target, false, + this->LocalGenerator->AppendCustomCommand(commands, ccg, + this->GeneratorTarget, false, cmLocalGenerator::HOME_OUTPUT, &content); @@ -1231,7 +1240,7 @@ void cmMakefileTargetGenerator std::string srcFullPath = this->Convert(idi->second, cmLocalGenerator::FULL); this->LocalGenerator-> - AddImplicitDepends(*this->Target, idi->first, + AddImplicitDepends(this->GeneratorTarget, idi->first, objFullPath.c_str(), srcFullPath.c_str()); } @@ -1242,7 +1251,7 @@ void cmMakefileTargetGenerator ::MakeEchoProgress(cmLocalUnixMakefileGenerator3::EchoProgress& progress) const { - progress.Dir = this->Makefile->GetHomeOutputDirectory(); + progress.Dir = this->LocalGenerator->GetBinaryDirectory(); progress.Dir += cmake::GetCMakeFilesDirectory(); std::ostringstream progressArg; progressArg << "$(CMAKE_PROGRESS_" << this->NumberOfProgressActions << ")"; @@ -1259,10 +1268,10 @@ cmMakefileTargetGenerator // Write a make variable assignment that lists all objects for the // target. variableName = - this->LocalGenerator->CreateMakeVariable(this->Target->GetName(), + this->LocalGenerator->CreateMakeVariable(this->GeneratorTarget->GetName(), "_OBJECTS"); *this->BuildFileStream - << "# Object files for target " << this->Target->GetName() << "\n" + << "# Object files for target " << this->GeneratorTarget->GetName() << "\n" << variableName << " ="; std::string object; const char* lineContinue = @@ -1284,12 +1293,12 @@ cmMakefileTargetGenerator // Write a make variable assignment that lists all external objects // for the target. variableNameExternal = - this->LocalGenerator->CreateMakeVariable(this->Target->GetName(), + this->LocalGenerator->CreateMakeVariable(this->GeneratorTarget->GetName(), "_EXTERNAL_OBJECTS"); *this->BuildFileStream << "\n" << "# External object files for target " - << this->Target->GetName() << "\n" + << this->GeneratorTarget->GetName() << "\n" << variableNameExternal << " ="; for(std::vector<std::string>::const_iterator i = this->ExternalObjects.begin(); @@ -1394,7 +1403,7 @@ void cmMakefileTargetGenerator::WriteTargetDriverRule( { // Compute the name of the driver target. std::string dir = - this->LocalGenerator->GetRelativeTargetDirectory(*this->Target); + this->LocalGenerator->GetRelativeTargetDirectory(this->GeneratorTarget); std::string buildTargetRuleName = dir; buildTargetRuleName += relink?"/preinstall":"/build"; buildTargetRuleName = this->Convert(buildTargetRuleName, @@ -1439,7 +1448,7 @@ void cmMakefileTargetGenerator ::AppendTargetDepends(std::vector<std::string>& depends) { // Static libraries never depend on anything for linking. - if(this->Target->GetType() == cmTarget::STATIC_LIBRARY) + if(this->GeneratorTarget->GetType() == cmState::STATIC_LIBRARY) { return; } @@ -1488,9 +1497,9 @@ void cmMakefileTargetGenerator this->AppendTargetDepends(depends); // Add a dependency on the link definitions file, if any. - if(!this->ModuleDefinitionFile.empty()) + if(this->ModuleDefinitionFile) { - depends.push_back(this->ModuleDefinitionFile); + depends.push_back(this->ModuleDefinitionFile->GetFullPath()); } // Add a dependency on user-specified manifest files, if any. @@ -1504,7 +1513,7 @@ void cmMakefileTargetGenerator // Add user-specified dependencies. if(const char* linkDepends = - this->Target->GetProperty("LINK_DEPENDS")) + this->GeneratorTarget->GetProperty("LINK_DEPENDS")) { cmSystemTools::ExpandListArgument(linkDepends, depends); } @@ -1515,7 +1524,7 @@ std::string cmMakefileTargetGenerator::GetLinkRule( const std::string& linkRuleVar) { std::string linkRule = this->Makefile->GetRequiredDefinition(linkRuleVar); - if(this->Target->HasImplibGNUtoMS()) + if(this->GeneratorTarget->HasImplibGNUtoMS()) { std::string ruleVar = "CMAKE_"; ruleVar += this->GeneratorTarget->GetLinkerLanguage(this->ConfigName); diff --git a/Source/cmMakefileTargetGenerator.h b/Source/cmMakefileTargetGenerator.h index fd4527b..38f40c0 100644 --- a/Source/cmMakefileTargetGenerator.h +++ b/Source/cmMakefileTargetGenerator.h @@ -18,14 +18,12 @@ #include "cmOSXBundleGenerator.h" class cmCustomCommandGenerator; -class cmDependInformation; class cmDepends; class cmGeneratorTarget; class cmGeneratedFileStream; class cmGlobalUnixMakefileGenerator3; class cmLocalUnixMakefileGenerator3; class cmMakefile; -class cmTarget; class cmSourceFile; /** \class cmMakefileTargetGenerator @@ -52,7 +50,6 @@ public: std::string GetProgressFileNameFull() { return this->ProgressFileNameFull; } - cmTarget* GetTarget() { return this->Target;} cmGeneratorTarget* GetGeneratorTarget() { return this->GeneratorTarget;} protected: diff --git a/Source/cmMakefileUtilityTargetGenerator.cxx b/Source/cmMakefileUtilityTargetGenerator.cxx index 303ca63..5b62cbf 100644 --- a/Source/cmMakefileUtilityTargetGenerator.cxx +++ b/Source/cmMakefileUtilityTargetGenerator.cxx @@ -16,7 +16,6 @@ #include "cmLocalUnixMakefileGenerator3.h" #include "cmMakefile.h" #include "cmSourceFile.h" -#include "cmTarget.h" //---------------------------------------------------------------------------- cmMakefileUtilityTargetGenerator @@ -42,7 +41,8 @@ void cmMakefileUtilityTargetGenerator::WriteRuleFiles() this->CreateRuleFile(); *this->BuildFileStream - << "# Utility rule file for " << this->Target->GetName() << ".\n\n"; + << "# Utility rule file for " + << this->GeneratorTarget->GetName() << ".\n\n"; if(!this->NoRuleMessages) { @@ -67,19 +67,21 @@ void cmMakefileUtilityTargetGenerator::WriteRuleFiles() // Utility targets store their rules in pre- and post-build commands. this->LocalGenerator->AppendCustomDepends - (depends, this->Target->GetPreBuildCommands()); + (depends, this->GeneratorTarget->GetPreBuildCommands()); this->LocalGenerator->AppendCustomDepends - (depends, this->Target->GetPostBuildCommands()); + (depends, this->GeneratorTarget->GetPostBuildCommands()); this->LocalGenerator->AppendCustomCommands - (commands, this->Target->GetPreBuildCommands(), this->Target); + (commands, this->GeneratorTarget->GetPreBuildCommands(), + this->GeneratorTarget); // Depend on all custom command outputs for sources this->DriveCustomCommands(depends); this->LocalGenerator->AppendCustomCommands - (commands, this->Target->GetPostBuildCommands(), this->Target); + (commands, this->GeneratorTarget->GetPostBuildCommands(), + this->GeneratorTarget); // Add dependencies on targets that must be built first. this->AppendTargetDepends(depends); @@ -101,11 +103,11 @@ void cmMakefileUtilityTargetGenerator::WriteRuleFiles() // Write the rule. this->LocalGenerator->WriteMakeRule(*this->BuildFileStream, 0, - this->Target->GetName(), + this->GeneratorTarget->GetName(), depends, commands, true); // Write the main driver rule to build everything in this target. - this->WriteTargetDriverRule(this->Target->GetName(), false); + this->WriteTargetDriverRule(this->GeneratorTarget->GetName(), false); // Write clean target this->WriteTargetCleanRules(); diff --git a/Source/cmMarkAsAdvancedCommand.cxx b/Source/cmMarkAsAdvancedCommand.cxx index 10d30f3..8d0e2b3 100644 --- a/Source/cmMarkAsAdvancedCommand.cxx +++ b/Source/cmMarkAsAdvancedCommand.cxx @@ -39,7 +39,8 @@ bool cmMarkAsAdvancedCommand cmState* state = this->Makefile->GetState(); if (!state->GetCacheEntryValue(variable)) { - state->AddCacheEntry(variable, 0, 0, cmState::UNINITIALIZED); + this->Makefile->GetCMakeInstance()->AddCacheEntry( + variable, 0, 0, cmState::UNINITIALIZED); overwrite = true; } if (!state->GetCacheEntryValue(variable)) diff --git a/Source/cmNinjaNormalTargetGenerator.cxx b/Source/cmNinjaNormalTargetGenerator.cxx index 84c19a3..17561b5 100644 --- a/Source/cmNinjaNormalTargetGenerator.cxx +++ b/Source/cmNinjaNormalTargetGenerator.cxx @@ -41,7 +41,7 @@ cmNinjaNormalTargetGenerator(cmGeneratorTarget* target) , TargetLinkLanguage("") { this->TargetLinkLanguage = target->GetLinkerLanguage(this->GetConfigName()); - if (target->GetType() == cmTarget::EXECUTABLE) + if (target->GetType() == cmState::EXECUTABLE) this->GetGeneratorTarget()->GetExecutableNames(this->TargetNameOut, this->TargetNameReal, this->TargetNameImport, @@ -55,11 +55,11 @@ cmNinjaNormalTargetGenerator(cmGeneratorTarget* target) this->TargetNamePDB, GetLocalGenerator()->GetConfigName()); - if(target->GetType() != cmTarget::OBJECT_LIBRARY) + if(target->GetType() != cmState::OBJECT_LIBRARY) { // on Windows the output dir is already needed at compile time // ensure the directory exists (OutDir test) - EnsureDirectoryExists(target->Target->GetDirectory(this->GetConfigName())); + EnsureDirectoryExists(target->GetDirectory(this->GetConfigName())); } this->OSXBundleGenerator = new cmOSXBundleGenerator(target, @@ -77,7 +77,7 @@ void cmNinjaNormalTargetGenerator::Generate() if (this->TargetLinkLanguage.empty()) { cmSystemTools::Error("CMake can not determine linker language for " "target: ", - this->GetTarget()->GetName().c_str()); + this->GetGeneratorTarget()->GetName().c_str()); return; } @@ -87,7 +87,7 @@ void cmNinjaNormalTargetGenerator::Generate() // Write the build statements this->WriteObjectBuildStatements(); - if(this->GetTarget()->GetType() == cmTarget::OBJECT_LIBRARY) + if(this->GetGeneratorTarget()->GetType() == cmState::OBJECT_LIBRARY) { this->WriteObjectLibStatement(); } @@ -103,7 +103,7 @@ void cmNinjaNormalTargetGenerator::WriteLanguagesRules() cmGlobalNinjaGenerator::WriteDivider(this->GetRulesFileStream()); this->GetRulesFileStream() << "# Rules for each languages for " - << cmTarget::GetTargetTypeName(this->GetTarget()->GetType()) + << cmState::GetTargetTypeName(this->GetGeneratorTarget()->GetType()) << " target " << this->GetTargetName() << "\n\n"; @@ -112,7 +112,7 @@ void cmNinjaNormalTargetGenerator::WriteLanguagesRules() // Write rules for languages compiled in this target. std::set<std::string> languages; std::vector<cmSourceFile*> sourceFiles; - this->GetTarget()->GetSourceFiles(sourceFiles, + this->GetGeneratorTarget()->GetSourceFiles(sourceFiles, this->GetMakefile()->GetSafeDefinition("CMAKE_BUILD_TYPE")); for(std::vector<cmSourceFile*>::const_iterator i = sourceFiles.begin(); i != sourceFiles.end(); ++i) @@ -133,17 +133,17 @@ void cmNinjaNormalTargetGenerator::WriteLanguagesRules() const char *cmNinjaNormalTargetGenerator::GetVisibleTypeName() const { - switch (this->GetTarget()->GetType()) { - case cmTarget::STATIC_LIBRARY: + switch (this->GetGeneratorTarget()->GetType()) { + case cmState::STATIC_LIBRARY: return "static library"; - case cmTarget::SHARED_LIBRARY: + case cmState::SHARED_LIBRARY: return "shared library"; - case cmTarget::MODULE_LIBRARY: - if (this->GetTarget()->IsCFBundleOnApple()) + case cmState::MODULE_LIBRARY: + if (this->GetGeneratorTarget()->IsCFBundleOnApple()) return "CFBundle shared module"; else return "shared module"; - case cmTarget::EXECUTABLE: + case cmState::EXECUTABLE: return "executable"; default: return 0; @@ -156,9 +156,10 @@ cmNinjaNormalTargetGenerator { return this->TargetLinkLanguage + "_" - + cmTarget::GetTargetTypeName(this->GetTarget()->GetType()) + + cmState::GetTargetTypeName(this->GetGeneratorTarget()->GetType()) + "_LINKER__" - + cmGlobalNinjaGenerator::EncodeRuleName(this->GetTarget()->GetName()) + + cmGlobalNinjaGenerator::EncodeRuleName( + this->GetGeneratorTarget()->GetName()) ; } @@ -166,7 +167,8 @@ void cmNinjaNormalTargetGenerator ::WriteLinkRule(bool useResponseFile) { - cmTarget::TargetType targetType = this->GetTarget()->GetType(); + cmState::TargetType targetType = + this->GetGeneratorTarget()->GetType(); std::string ruleName = this->LanguageLinkerRule(); // Select whether to use a response file for objects. @@ -176,7 +178,7 @@ cmNinjaNormalTargetGenerator if (!this->GetGlobalGenerator()->HasRule(ruleName)) { cmLocalGenerator::RuleVariables vars; vars.RuleLauncher = "RULE_LAUNCH_LINK"; - vars.CMTarget = this->GetTarget(); + vars.CMTarget = this->GetGeneratorTarget(); vars.Language = this->TargetLinkLanguage.c_str(); std::string responseFlag; @@ -226,7 +228,7 @@ cmNinjaNormalTargetGenerator std::ostringstream minorStream; int major; int minor; - this->GetTarget()->GetTargetVersion(major, minor); + this->GetGeneratorTarget()->GetTargetVersion(major, minor); majorStream << major; minorStream << minor; targetVersionMajor = majorStream.str(); @@ -240,7 +242,7 @@ cmNinjaNormalTargetGenerator vars.Manifests = "$MANIFESTS"; std::string langFlags; - if (targetType != cmTarget::EXECUTABLE) + if (targetType != cmState::EXECUTABLE) { langFlags += "$LANGUAGE_COMPILE_FLAGS $ARCH_FLAGS"; vars.LanguageCompileFlags = langFlags.c_str(); @@ -279,11 +281,11 @@ cmNinjaNormalTargetGenerator } if (this->TargetNameOut != this->TargetNameReal && - !this->GetTarget()->IsFrameworkOnApple()) { + !this->GetGeneratorTarget()->IsFrameworkOnApple()) { std::string cmakeCommand = this->GetLocalGenerator()->ConvertToOutputFormat( cmSystemTools::GetCMakeCommand(), cmLocalGenerator::SHELL); - if (targetType == cmTarget::EXECUTABLE) + if (targetType == cmState::EXECUTABLE) this->GetGlobalGenerator()->AddRule("CMAKE_SYMLINK_EXECUTABLE", cmakeCommand + " -E cmake_symlink_executable" @@ -330,8 +332,8 @@ cmNinjaNormalTargetGenerator return linkCmds; } } - switch (this->GetTarget()->GetType()) { - case cmTarget::STATIC_LIBRARY: { + switch (this->GetGeneratorTarget()->GetType()) { + case cmState::STATIC_LIBRARY: { // We have archive link commands set. First, delete the existing archive. { std::string cmakeCommand = @@ -356,9 +358,9 @@ cmNinjaNormalTargetGenerator } return linkCmds; } - case cmTarget::SHARED_LIBRARY: - case cmTarget::MODULE_LIBRARY: - case cmTarget::EXECUTABLE: + case cmState::SHARED_LIBRARY: + case cmState::MODULE_LIBRARY: + case cmState::EXECUTABLE: break; default: assert(0 && "Unexpected target type"); @@ -397,7 +399,6 @@ static int calculateCommandLineLengthLimit(int linkRuleLength) void cmNinjaNormalTargetGenerator::WriteLinkStatement() { - cmTarget& target = *this->GetTarget(); cmGeneratorTarget& gt = *this->GetGeneratorTarget(); const std::string cfgName = this->GetConfigName(); std::string targetOutput = ConvertToNinjaPath( @@ -410,10 +411,10 @@ void cmNinjaNormalTargetGenerator::WriteLinkStatement() gt.GetFullPath(cfgName, /*implib=*/true)); - if (target.IsAppBundleOnApple()) + if (gt.IsAppBundleOnApple()) { // Create the app bundle - std::string outpath = target.GetDirectory(cfgName); + std::string outpath = gt.GetDirectory(cfgName); this->OSXBundleGenerator->CreateAppBundle(this->TargetNameOut, outpath); // Calculate the output path @@ -426,25 +427,25 @@ void cmNinjaNormalTargetGenerator::WriteLinkStatement() targetOutputReal += this->TargetNameReal; targetOutputReal = this->ConvertToNinjaPath(targetOutputReal); } - else if (target.IsFrameworkOnApple()) + else if (gt.IsFrameworkOnApple()) { // Create the library framework. this->OSXBundleGenerator->CreateFramework(this->TargetNameOut, - target.GetDirectory(cfgName)); + gt.GetDirectory(cfgName)); } - else if(target.IsCFBundleOnApple()) + else if(gt.IsCFBundleOnApple()) { // Create the core foundation bundle. this->OSXBundleGenerator->CreateCFBundle(this->TargetNameOut, - target.GetDirectory(cfgName)); + gt.GetDirectory(cfgName)); } // Write comments. cmGlobalNinjaGenerator::WriteDivider(this->GetBuildFileStream()); - const cmTarget::TargetType targetType = target.GetType(); + const cmState::TargetType targetType = gt.GetType(); this->GetBuildFileStream() << "# Link build statements for " - << cmTarget::GetTargetTypeName(targetType) + << cmState::GetTargetTypeName(targetType) << " target " << this->GetTargetName() << "\n\n"; @@ -488,14 +489,13 @@ void cmNinjaNormalTargetGenerator::WriteLinkStatement() &genTarget, useWatcomQuote); if(this->GetMakefile()->IsOn("CMAKE_SUPPORT_WINDOWS_EXPORT_ALL_SYMBOLS") - && target.GetType() == cmTarget::SHARED_LIBRARY) + && gt.GetType() == cmState::SHARED_LIBRARY) { - if(target.GetPropertyAsBool("WINDOWS_EXPORT_ALL_SYMBOLS")) + if(gt.GetPropertyAsBool("WINDOWS_EXPORT_ALL_SYMBOLS")) { - std::string dllname = targetOutput; std::string name_of_def_file - = target.GetSupportDirectory(); - name_of_def_file += "/" + target.GetName(); + = gt.GetSupportDirectory(); + name_of_def_file += "/" + gt.GetName(); name_of_def_file += ".def "; vars["LINK_FLAGS"] += " /DEF:"; vars["LINK_FLAGS"] += this->GetLocalGenerator() @@ -504,7 +504,7 @@ void cmNinjaNormalTargetGenerator::WriteLinkStatement() } } - this->addPoolNinjaVariable("JOB_POOL_LINK", &target, vars); + this->addPoolNinjaVariable("JOB_POOL_LINK", >, vars); this->AddModuleDefinitionFlag(vars["LINK_FLAGS"]); vars["LINK_FLAGS"] = cmGlobalNinjaGenerator @@ -517,7 +517,7 @@ void cmNinjaNormalTargetGenerator::WriteLinkStatement() // Compute architecture specific link flags. Yes, these go into a different // variable for executables, probably due to a mistake made when duplicating // code between the Makefile executable and library generators. - if (targetType == cmTarget::EXECUTABLE) + if (targetType == cmState::EXECUTABLE) { std::string t = vars["FLAGS"]; localGen.AddArchitectureFlags(t, &genTarget, TargetLinkLanguage, cfgName); @@ -537,7 +537,7 @@ void cmNinjaNormalTargetGenerator::WriteLinkStatement() { vars["SONAME_FLAG"] = mf->GetSONameFlag(this->TargetLinkLanguage); vars["SONAME"] = this->TargetNameSO; - if (targetType == cmTarget::SHARED_LIBRARY) + if (targetType == cmState::SHARED_LIBRARY) { std::string install_dir = this->GetGeneratorTarget()->GetInstallNameDirForBuildTree(cfgName); @@ -559,7 +559,7 @@ void cmNinjaNormalTargetGenerator::WriteLinkStatement() cmLocalGenerator::SHELL); vars["TARGET_IMPLIB"] = impLibPath; EnsureParentDirectoryExists(impLibPath); - if(target.HasImportLibrary()) + if(genTarget.HasImportLibrary()) { byproducts.push_back(targetOutputImplib); } @@ -582,7 +582,7 @@ void cmNinjaNormalTargetGenerator::WriteLinkStatement() vars["TARGET_PDB"] = base + suffix + dbg_suffix; } - const std::string objPath = GetTarget()->GetSupportDirectory(); + const std::string objPath = GetGeneratorTarget()->GetSupportDirectory(); vars["OBJECT_DIR"] = this->GetLocalGenerator()->ConvertToOutputFormat( this->ConvertToNinjaPath(objPath), cmLocalGenerator::SHELL); @@ -598,9 +598,9 @@ void cmNinjaNormalTargetGenerator::WriteLinkStatement() } const std::vector<cmCustomCommand> *cmdLists[3] = { - &target.GetPreBuildCommands(), - &target.GetPreLinkCommands(), - &target.GetPostBuildCommands() + >.GetPreBuildCommands(), + >.GetPreLinkCommands(), + >.GetPostBuildCommands() }; std::vector<std::string> preLinkCmdLines, postBuildCmdLines; @@ -625,17 +625,17 @@ void cmNinjaNormalTargetGenerator::WriteLinkStatement() } // maybe create .def file from list of objects - if (target.GetType() == cmTarget::SHARED_LIBRARY && + if (gt.GetType() == cmState::SHARED_LIBRARY && this->GetMakefile()->IsOn("CMAKE_SUPPORT_WINDOWS_EXPORT_ALL_SYMBOLS")) { - if(target.GetPropertyAsBool("WINDOWS_EXPORT_ALL_SYMBOLS")) + if(gt.GetPropertyAsBool("WINDOWS_EXPORT_ALL_SYMBOLS")) { std::string cmakeCommand = this->GetLocalGenerator()->ConvertToOutputFormat( cmSystemTools::GetCMakeCommand(), cmLocalGenerator::SHELL); std::string name_of_def_file - = target.GetSupportDirectory(); - name_of_def_file += "/" + target.GetName(); + = gt.GetSupportDirectory(); + name_of_def_file += "/" + gt.GetName(); name_of_def_file += ".def"; std::string cmd = cmakeCommand; cmd += " -E __create_def "; @@ -666,8 +666,8 @@ void cmNinjaNormalTargetGenerator::WriteLinkStatement() if (!preLinkCmdLines.empty()) { const std::string homeOutDir = localGen.ConvertToOutputFormat( - mf->GetHomeOutputDirectory(), - cmLocalGenerator::SHELL); + localGen.GetBinaryDirectory(), + cmLocalGenerator::SHELL); preLinkCmdLines.push_back("cd " + homeOutDir); } @@ -698,11 +698,11 @@ void cmNinjaNormalTargetGenerator::WriteLinkStatement() const std::string rspfile = std::string(cmake::GetCMakeFilesDirectoryPostSlash()) - + target.GetName() + ".rsp"; + + gt.GetName() + ".rsp"; // Gather order-only dependencies. cmNinjaDeps orderOnlyDeps; - this->GetLocalGenerator()->AppendTargetDepends(this->GetTarget(), + this->GetLocalGenerator()->AppendTargetDepends(this->GetGeneratorTarget(), orderOnlyDeps); // Ninja should restat after linking if and only if there are byproducts. @@ -731,9 +731,9 @@ void cmNinjaNormalTargetGenerator::WriteLinkStatement() &usedResponseFile); this->WriteLinkRule(usedResponseFile); - if (targetOutput != targetOutputReal && !target.IsFrameworkOnApple()) + if (targetOutput != targetOutputReal && !gt.IsFrameworkOnApple()) { - if (targetType == cmTarget::EXECUTABLE) + if (targetType == cmState::EXECUTABLE) { globalGen.WriteBuild(this->GetBuildFileStream(), "Create executable symlink " + targetOutput, @@ -771,8 +771,8 @@ void cmNinjaNormalTargetGenerator::WriteLinkStatement() } // Add aliases for the file name and the target name. - globalGen.AddTargetAlias(this->TargetNameOut, &target); - globalGen.AddTargetAlias(this->GetTargetName(), &target); + globalGen.AddTargetAlias(this->TargetNameOut, >); + globalGen.AddTargetAlias(this->GetTargetName(), >); } //---------------------------------------------------------------------------- @@ -780,7 +780,8 @@ void cmNinjaNormalTargetGenerator::WriteObjectLibStatement() { // Write a phony output that depends on all object files. cmNinjaDeps outputs; - this->GetLocalGenerator()->AppendTargetOutputs(this->GetTarget(), outputs); + this->GetLocalGenerator()->AppendTargetOutputs(this->GetGeneratorTarget(), + outputs); cmNinjaDeps depends = this->GetObjects(); this->GetGlobalGenerator()->WritePhonyBuild(this->GetBuildFileStream(), "Object library " @@ -790,5 +791,5 @@ void cmNinjaNormalTargetGenerator::WriteObjectLibStatement() // Add aliases for the target name. this->GetGlobalGenerator()->AddTargetAlias(this->GetTargetName(), - this->GetTarget()); + this->GetGeneratorTarget()); } diff --git a/Source/cmNinjaTargetGenerator.cxx b/Source/cmNinjaTargetGenerator.cxx index 6e6dc60..5ff4fdb 100644 --- a/Source/cmNinjaTargetGenerator.cxx +++ b/Source/cmNinjaTargetGenerator.cxx @@ -31,23 +31,22 @@ cmNinjaTargetGenerator::New(cmGeneratorTarget* target) { switch (target->GetType()) { - case cmTarget::EXECUTABLE: - case cmTarget::SHARED_LIBRARY: - case cmTarget::STATIC_LIBRARY: - case cmTarget::MODULE_LIBRARY: - case cmTarget::OBJECT_LIBRARY: + case cmState::EXECUTABLE: + case cmState::SHARED_LIBRARY: + case cmState::STATIC_LIBRARY: + case cmState::MODULE_LIBRARY: + case cmState::OBJECT_LIBRARY: return new cmNinjaNormalTargetGenerator(target); - case cmTarget::UTILITY: + case cmState::UTILITY: return new cmNinjaUtilityTargetGenerator(target);; - case cmTarget::GLOBAL_TARGET: { + case cmState::GLOBAL_TARGET: { // We only want to process global targets that live in the home // (i.e. top-level) directory. CMake creates copies of these targets // in every directory, which we don't need. - cmMakefile *mf = target->Target->GetMakefile(); - if (strcmp(mf->GetCurrentSourceDirectory(), - mf->GetHomeDirectory()) == 0) + if (strcmp(target->GetLocalGenerator()->GetCurrentSourceDirectory(), + target->GetLocalGenerator()->GetSourceDirectory()) == 0) return new cmNinjaUtilityTargetGenerator(target); // else fallthrough } @@ -93,7 +92,7 @@ std::string cmNinjaTargetGenerator::LanguageCompilerRule( const std::string& lang) const { return lang + "_COMPILER__" + - cmGlobalNinjaGenerator::EncodeRuleName(this->Target->GetName()); + cmGlobalNinjaGenerator::EncodeRuleName(this->GeneratorTarget->GetName()); } std::string @@ -149,17 +148,9 @@ void cmNinjaTargetGenerator::AddIncludeFlags(std::string& languageFlags, bool cmNinjaTargetGenerator::NeedDepTypeMSVC(const std::string& lang) const { - if (lang == "C" || lang == "CXX") - { - cmMakefile* mf = this->GetMakefile(); - return ( - strcmp(mf->GetSafeDefinition("CMAKE_C_COMPILER_ID"), "MSVC") == 0 || - strcmp(mf->GetSafeDefinition("CMAKE_CXX_COMPILER_ID"), "MSVC") == 0 || - strcmp(mf->GetSafeDefinition("CMAKE_C_SIMULATE_ID"), "MSVC") == 0 || - strcmp(mf->GetSafeDefinition("CMAKE_CXX_SIMULATE_ID"), "MSVC") == 0 - ); - } - return false; + return strcmp( + this->GetMakefile()->GetSafeDefinition("CMAKE_NINJA_DEPTYPE_" + lang), + "msvc") == 0; } // TODO: Refactor with @@ -190,8 +181,8 @@ ComputeDefines(cmSourceFile const* source, const std::string& language) cmNinjaDeps cmNinjaTargetGenerator::ComputeLinkDeps() const { // Static libraries never depend on other targets for linking. - if (this->Target->GetType() == cmTarget::STATIC_LIBRARY || - this->Target->GetType() == cmTarget::OBJECT_LIBRARY) + if (this->GeneratorTarget->GetType() == cmState::STATIC_LIBRARY || + this->GeneratorTarget->GetType() == cmState::OBJECT_LIBRARY) return cmNinjaDeps(); cmComputeLinkInformation* cli = @@ -204,9 +195,10 @@ cmNinjaDeps cmNinjaTargetGenerator::ComputeLinkDeps() const std::transform(deps.begin(), deps.end(), result.begin(), MapToNinjaPath()); // Add a dependency on the link definitions file, if any. - if(!this->ModuleDefinitionFile.empty()) + if(this->ModuleDefinitionFile) { - result.push_back(this->ConvertToNinjaPath(this->ModuleDefinitionFile)); + result.push_back(this->ConvertToNinjaPath( + this->ModuleDefinitionFile->GetFullPath())); } // Add a dependency on user-specified manifest files, if any. @@ -219,7 +211,8 @@ cmNinjaDeps cmNinjaTargetGenerator::ComputeLinkDeps() const } // Add user-specified dependencies. - if (const char* linkDepends = this->Target->GetProperty("LINK_DEPENDS")) + if (const char* linkDepends = + this->GeneratorTarget->GetProperty("LINK_DEPENDS")) { std::vector<std::string> linkDeps; cmSystemTools::ExpandListArgument(linkDepends, linkDeps); @@ -246,7 +239,7 @@ cmNinjaTargetGenerator path += "/"; std::string const& objectName = this->GeneratorTarget ->GetObjectName(source); - path += this->LocalGenerator->GetTargetDirectory(*this->Target); + path += this->LocalGenerator->GetTargetDirectory(this->GeneratorTarget); path += "/"; path += objectName; return path; @@ -254,7 +247,7 @@ cmNinjaTargetGenerator std::string cmNinjaTargetGenerator::GetTargetOutputDir() const { - std::string dir = this->Target->GetDirectory(this->GetConfigName()); + std::string dir = this->GeneratorTarget->GetDirectory(this->GetConfigName()); return ConvertToNinjaPath(dir); } @@ -272,7 +265,7 @@ cmNinjaTargetGenerator std::string cmNinjaTargetGenerator::GetTargetName() const { - return this->Target->GetName(); + return this->GeneratorTarget->GetName(); } @@ -284,22 +277,22 @@ bool cmNinjaTargetGenerator::SetMsvcTargetPdbVariable(cmNinjaVars& vars) const { std::string pdbPath; std::string compilePdbPath; - if(this->Target->GetType() == cmTarget::EXECUTABLE || - this->Target->GetType() == cmTarget::STATIC_LIBRARY || - this->Target->GetType() == cmTarget::SHARED_LIBRARY || - this->Target->GetType() == cmTarget::MODULE_LIBRARY) + if(this->GeneratorTarget->GetType() == cmState::EXECUTABLE || + this->GeneratorTarget->GetType() == cmState::STATIC_LIBRARY || + this->GeneratorTarget->GetType() == cmState::SHARED_LIBRARY || + this->GeneratorTarget->GetType() == cmState::MODULE_LIBRARY) { - pdbPath = this->Target->GetPDBDirectory(this->GetConfigName()); + pdbPath = this->GeneratorTarget->GetPDBDirectory(this->GetConfigName()); pdbPath += "/"; pdbPath += this->GeneratorTarget->GetPDBName(this->GetConfigName()); } - if(this->Target->GetType() <= cmTarget::OBJECT_LIBRARY) + if(this->GeneratorTarget->GetType() <= cmState::OBJECT_LIBRARY) { compilePdbPath = this->GeneratorTarget->GetCompilePDBPath(this->GetConfigName()); if(compilePdbPath.empty()) { - compilePdbPath = this->Target->GetSupportDirectory() + "/"; + compilePdbPath = this->GeneratorTarget->GetSupportDirectory() + "/"; } } @@ -335,7 +328,7 @@ cmNinjaTargetGenerator { cmLocalGenerator::RuleVariables vars; vars.RuleLauncher = "RULE_LAUNCH_COMPILE"; - vars.CMTarget = this->GetTarget(); + vars.CMTarget = this->GetGeneratorTarget(); vars.Language = lang.c_str(); vars.Source = "$in"; vars.Object = "$out"; @@ -359,7 +352,7 @@ cmNinjaTargetGenerator depfile = ""; flags += " /showIncludes"; } - else if (lang == "RC" && this->NeedDepTypeMSVC("C")) + else if (mf->IsOn("CMAKE_NINJA_CMCLDEPS_"+lang)) { // For the MS resource compiler we need cmcldeps, but skip dependencies // for source-file try_compile cases because they are always fresh. @@ -411,7 +404,7 @@ cmNinjaTargetGenerator if (!compileCmds.empty() && (lang == "C" || lang == "CXX")) { std::string const iwyu_prop = lang + "_INCLUDE_WHAT_YOU_USE"; - const char *iwyu = this->Target->GetProperty(iwyu_prop); + const char *iwyu = this->GeneratorTarget->GetProperty(iwyu_prop); if (iwyu && *iwyu) { std::string run_iwyu = @@ -428,7 +421,7 @@ cmNinjaTargetGenerator if (!compileCmds.empty() && (lang == "C" || lang == "CXX")) { std::string const clauncher_prop = lang + "_COMPILER_LAUNCHER"; - const char *clauncher = this->Target->GetProperty(clauncher_prop); + const char *clauncher = this->GeneratorTarget->GetProperty(clauncher_prop); if (clauncher && *clauncher) { std::vector<std::string> launcher_cmd; @@ -481,7 +474,7 @@ cmNinjaTargetGenerator cmGlobalNinjaGenerator::WriteDivider(this->GetBuildFileStream()); this->GetBuildFileStream() << "# Object build statements for " - << cmTarget::GetTargetTypeName(this->GetTarget()->GetType()) + << cmState::GetTargetTypeName(this->GetGeneratorTarget()->GetType()) << " target " << this->GetTargetName() << "\n\n"; @@ -494,7 +487,8 @@ cmNinjaTargetGenerator si != customCommands.end(); ++si) { cmCustomCommand const* cc = (*si)->GetCustomCommand(); - this->GetLocalGenerator()->AddCustomCommandTarget(cc, this->GetTarget()); + this->GetLocalGenerator()->AddCustomCommandTarget(cc, + this->GetGeneratorTarget()); // Record the custom commands for this target. The container is used // in WriteObjectBuildStatement when called in a loop below. this->CustomCommands.push_back(cc); @@ -519,7 +513,8 @@ cmNinjaTargetGenerator } cmNinjaDeps orderOnlyDeps; - this->GetLocalGenerator()->AppendTargetDepends(this->Target, orderOnlyDeps); + this->GetLocalGenerator()->AppendTargetDepends(this->GeneratorTarget, + orderOnlyDeps); // Add order-only dependencies on custom command outputs. for(std::vector<cmCustomCommand const*>::const_iterator @@ -568,7 +563,7 @@ cmNinjaTargetGenerator std::string const language = source->GetLanguage(); std::string const sourceFileName = language=="RC" ? source->GetFullPath() : this->GetSourceFilePath(source); - std::string const objectDir = this->Target->GetSupportDirectory(); + std::string const objectDir = this->GeneratorTarget->GetSupportDirectory(); std::string const objectFileName = this->GetObjectFilePath(source); std::string const objectFileDir = cmSystemTools::GetFilenamePath(objectFileName); @@ -641,7 +636,8 @@ cmNinjaTargetGenerator ConvertToNinjaPath(objectFileDir), cmLocalGenerator::SHELL); - this->addPoolNinjaVariable("JOB_POOL_COMPILE", this->GetTarget(), vars); + this->addPoolNinjaVariable("JOB_POOL_COMPILE", + this->GetGeneratorTarget(), vars); this->SetMsvcTargetPdbVariable(vars); @@ -790,7 +786,7 @@ cmNinjaTargetGenerator::MacOSXContentGeneratorType::operator()( void cmNinjaTargetGenerator::addPoolNinjaVariable( const std::string& pool_property, - cmTarget* target, + cmGeneratorTarget* target, cmNinjaVars& vars) { const char* pool = target->GetProperty(pool_property); diff --git a/Source/cmNinjaTargetGenerator.h b/Source/cmNinjaTargetGenerator.h index 0267f63..e3ec423 100644 --- a/Source/cmNinjaTargetGenerator.h +++ b/Source/cmNinjaTargetGenerator.h @@ -53,9 +53,6 @@ protected: cmGeneratedFileStream& GetBuildFileStream() const; cmGeneratedFileStream& GetRulesFileStream() const; - cmTarget* GetTarget() const - { return this->Target; } - cmGeneratorTarget* GetGeneratorTarget() const { return this->GeneratorTarget; } @@ -152,7 +149,7 @@ protected: std::set<std::string> MacContentFolders; void addPoolNinjaVariable(const std::string& pool_property, - cmTarget* target, + cmGeneratorTarget* target, cmNinjaVars& vars); private: diff --git a/Source/cmNinjaUtilityTargetGenerator.cxx b/Source/cmNinjaUtilityTargetGenerator.cxx index 58b901a..ac66fcd 100644 --- a/Source/cmNinjaUtilityTargetGenerator.cxx +++ b/Source/cmNinjaUtilityTargetGenerator.cxx @@ -16,7 +16,6 @@ #include "cmGlobalNinjaGenerator.h" #include "cmMakefile.h" #include "cmSourceFile.h" -#include "cmTarget.h" #include "cmCustomCommandGenerator.h" cmNinjaUtilityTargetGenerator::cmNinjaUtilityTargetGenerator( @@ -34,8 +33,8 @@ void cmNinjaUtilityTargetGenerator::Generate() cmNinjaDeps deps, outputs, util_outputs(1, utilCommandName); const std::vector<cmCustomCommand> *cmdLists[2] = { - &this->GetTarget()->GetPreBuildCommands(), - &this->GetTarget()->GetPostBuildCommands() + &this->GetGeneratorTarget()->GetPreBuildCommands(), + &this->GetGeneratorTarget()->GetPostBuildCommands() }; bool uses_terminal = false; @@ -58,7 +57,7 @@ void cmNinjaUtilityTargetGenerator::Generate() std::vector<cmSourceFile*> sources; std::string config = this->GetMakefile() ->GetSafeDefinition("CMAKE_BUILD_TYPE"); - this->GetTarget()->GetSourceFiles(sources, config); + this->GetGeneratorTarget()->GetSourceFiles(sources, config); for(std::vector<cmSourceFile*>::const_iterator source = sources.begin(); source != sources.end(); ++source) { @@ -66,7 +65,8 @@ void cmNinjaUtilityTargetGenerator::Generate() { cmCustomCommandGenerator ccg(*cc, this->GetConfigName(), this->GetLocalGenerator()); - this->GetLocalGenerator()->AddCustomCommandTarget(cc, this->GetTarget()); + this->GetLocalGenerator()->AddCustomCommandTarget(cc, + this->GetGeneratorTarget()); // Depend on all custom command outputs. const std::vector<std::string>& ccOutputs = ccg.GetOutputs(); @@ -78,8 +78,10 @@ void cmNinjaUtilityTargetGenerator::Generate() } } - this->GetLocalGenerator()->AppendTargetOutputs(this->GetTarget(), outputs); - this->GetLocalGenerator()->AppendTargetDepends(this->GetTarget(), deps); + this->GetLocalGenerator()->AppendTargetOutputs(this->GetGeneratorTarget(), + outputs); + this->GetLocalGenerator()->AppendTargetDepends(this->GetGeneratorTarget(), + deps); if (commands.empty()) { this->GetGlobalGenerator()->WritePhonyBuild(this->GetBuildFileStream(), @@ -90,7 +92,8 @@ void cmNinjaUtilityTargetGenerator::Generate() } else { std::string command = this->GetLocalGenerator()->BuildCommandLine(commands); - const char *echoStr = this->GetTarget()->GetProperty("EchoString"); + const char *echoStr = + this->GetGeneratorTarget()->GetProperty("EchoString"); std::string desc; if (echoStr) desc = echoStr; @@ -103,13 +106,13 @@ void cmNinjaUtilityTargetGenerator::Generate() command, "$(CMAKE_SOURCE_DIR)", this->GetLocalGenerator()->ConvertToOutputFormat( - this->GetTarget()->GetMakefile()->GetHomeDirectory(), + this->GetLocalGenerator()->GetSourceDirectory(), cmLocalGenerator::SHELL).c_str()); cmSystemTools::ReplaceString( command, "$(CMAKE_BINARY_DIR)", this->GetLocalGenerator()->ConvertToOutputFormat( - this->GetTarget()->GetMakefile()->GetHomeOutputDirectory(), + this->GetLocalGenerator()->GetBinaryDirectory(), cmLocalGenerator::SHELL).c_str()); cmSystemTools::ReplaceString(command, "$(ARGS)", ""); @@ -128,6 +131,7 @@ void cmNinjaUtilityTargetGenerator::Generate() desc, "Utility command for " + this->GetTargetName(), uses_terminal, + /*restat*/true, util_outputs, deps); @@ -139,5 +143,5 @@ void cmNinjaUtilityTargetGenerator::Generate() } this->GetGlobalGenerator()->AddTargetAlias(this->GetTargetName(), - this->GetTarget()); + this->GetGeneratorTarget()); } diff --git a/Source/cmOSXBundleGenerator.cxx b/Source/cmOSXBundleGenerator.cxx index 4fe99e3..934e198 100644 --- a/Source/cmOSXBundleGenerator.cxx +++ b/Source/cmOSXBundleGenerator.cxx @@ -34,7 +34,7 @@ cmOSXBundleGenerator(cmGeneratorTarget* target, //---------------------------------------------------------------------------- bool cmOSXBundleGenerator::MustSkip() { - return !this->GT->Target->HaveWellDefinedOutputFiles(); + return !this->GT->HaveWellDefinedOutputFiles(); } //---------------------------------------------------------------------------- @@ -59,7 +59,7 @@ void cmOSXBundleGenerator::CreateAppBundle(const std::string& targetName, plist += "/"; plist += this->GT->GetAppBundleDirectory(this->ConfigName, true); plist += "/Info.plist"; - this->LocalGenerator->GenerateAppleInfoPList(this->GT->Target, + this->LocalGenerator->GenerateAppleInfoPList(this->GT, targetName, plist.c_str()); this->Makefile->AddCMakeOutputFile(plist); @@ -83,17 +83,26 @@ void cmOSXBundleGenerator::CreateFramework( std::string newoutpath = outpath + "/" + this->GT->GetFrameworkDirectory(this->ConfigName, false); - std::string frameworkVersion = this->GT->Target->GetFrameworkVersion(); + std::string frameworkVersion = this->GT->GetFrameworkVersion(); - // Configure the Info.plist file into the Resources directory. - this->MacContentFolders->insert("Resources"); + // Configure the Info.plist file std::string plist = newoutpath; - plist += "/Resources/Info.plist"; + if (!this->Makefile->PlatformIsAppleIos()) + { + // Put the Info.plist file into the Resources directory. + this->MacContentFolders->insert("Resources"); + plist += "/Resources"; + } + plist += "/Info.plist"; std::string name = cmSystemTools::GetFilenameName(targetName); - this->LocalGenerator->GenerateFrameworkInfoPList(this->GT->Target, + this->LocalGenerator->GenerateFrameworkInfoPList(this->GT, name, plist.c_str()); + // Generate Versions directory only for MacOSX frameworks + if (this->Makefile->PlatformIsAppleIos()) + return; + // TODO: Use the cmMakefileTargetGenerator::ExtraFiles vector to // drive rules to create these files at build time. std::string oldName; @@ -182,7 +191,7 @@ void cmOSXBundleGenerator::CreateCFBundle(const std::string& targetName, this->GT->GetCFBundleDirectory(this->ConfigName, true); plist += "/Info.plist"; std::string name = cmSystemTools::GetFilenameName(targetName); - this->LocalGenerator->GenerateAppleInfoPList(this->GT->Target, + this->LocalGenerator->GenerateAppleInfoPList(this->GT, name, plist.c_str()); this->Makefile->AddCMakeOutputFile(plist); diff --git a/Source/cmOrderDirectories.cxx b/Source/cmOrderDirectories.cxx index 35ee127..e3eedc7 100644 --- a/Source/cmOrderDirectories.cxx +++ b/Source/cmOrderDirectories.cxx @@ -555,7 +555,7 @@ void cmOrderDirectories::FindImplicitConflicts() << "Some of these libraries may not be found correctly."; this->GlobalGenerator->GetCMakeInstance() ->IssueMessage(cmake::WARNING, w.str(), - this->Target->Target->GetBacktrace()); + this->Target->GetBacktrace()); } //---------------------------------------------------------------------------- @@ -637,5 +637,5 @@ void cmOrderDirectories::DiagnoseCycle() e << "Some of these libraries may not be found correctly."; this->GlobalGenerator->GetCMakeInstance() ->IssueMessage(cmake::WARNING, e.str(), - this->Target->Target->GetBacktrace()); + this->Target->GetBacktrace()); } diff --git a/Source/cmOutputRequiredFilesCommand.cxx b/Source/cmOutputRequiredFilesCommand.cxx index 2d57d3b..54208ac 100644 --- a/Source/cmOutputRequiredFilesCommand.cxx +++ b/Source/cmOutputRequiredFilesCommand.cxx @@ -10,108 +10,239 @@ See the License for more information. ============================================================================*/ #include "cmOutputRequiredFilesCommand.h" -#include "cmMakeDepend.h" #include "cmAlgorithms.h" #include <cmsys/FStream.hxx> -class cmLBDepend : public cmMakeDepend +/** \class cmDependInformation + * \brief Store dependency information for a single source file. + * + * This structure stores the depend information for a single source file. + */ +class cmDependInformation { +public: /** - * Compute the depend information for this class. + * Construct with dependency generation marked not done; instance + * not placed in cmMakefile's list. */ - virtual void DependWalk(cmDependInformation* info); -}; + cmDependInformation(): DependDone(false), SourceFile(0) {} -void cmLBDepend::DependWalk(cmDependInformation* info) -{ - cmsys::ifstream fin(info->FullPath.c_str()); - if(!fin) + /** + * The set of files on which this one depends. + */ + typedef std::set<cmDependInformation*> DependencySetType; + DependencySetType DependencySet; + + /** + * This flag indicates whether dependency checking has been + * performed for this file. + */ + bool DependDone; + + /** + * If this object corresponds to a cmSourceFile instance, this points + * to it. + */ + const cmSourceFile *SourceFile; + + /** + * Full path to this file. + */ + std::string FullPath; + + /** + * Full path not including file name. + */ + std::string PathOnly; + + /** + * Name used to #include this file. + */ + std::string IncludeName; + + /** + * This method adds the dependencies of another file to this one. + */ + void AddDependencies(cmDependInformation* info) + { + if(this != info) { - cmSystemTools::Error("error can not open ", info->FullPath.c_str()); - return; + this->DependencySet.insert(info); } + } +}; - std::string line; - while(cmSystemTools::GetLineFromStream(fin, line)) - { - if(cmHasLiteralPrefix(line.c_str(), "#include")) - { - // if it is an include line then create a string class - std::string currentline = line; - size_t qstart = currentline.find('\"', 8); - size_t qend; - // if a quote is not found look for a < - if(qstart == std::string::npos) - { - qstart = currentline.find('<', 8); - // if a < is not found then move on - if(qstart == std::string::npos) - { - cmSystemTools::Error("unknown include directive ", - currentline.c_str() ); - continue; - } - else - { - qend = currentline.find('>', qstart+1); - } - } - else +class cmLBDepend +{ +public: + /** + * Construct the object with verbose turned off. + */ + cmLBDepend() + { + this->Verbose = false; + this->IncludeFileRegularExpression.compile("^.*$"); + this->ComplainFileRegularExpression.compile("^$"); + } + + /** + * Destructor. + */ + ~cmLBDepend() + { + cmDeleteAll(this->DependInformationMap); + } + + /** + * Set the makefile that is used as a source of classes. + */ + void SetMakefile(cmMakefile* makefile) + { + this->Makefile = makefile; + + // Now extract the include file regular expression from the makefile. + this->IncludeFileRegularExpression.compile( + this->Makefile->GetIncludeRegularExpression()); + this->ComplainFileRegularExpression.compile( + this->Makefile->GetComplainRegularExpression()); + + // Now extract any include paths from the targets + std::set<std::string> uniqueIncludes; + std::vector<std::string> orderedAndUniqueIncludes; + cmTargets &targets = this->Makefile->GetTargets(); + for (cmTargets::iterator l = targets.begin(); + l != targets.end(); ++l) + { + const char *incDirProp = l->second.GetProperty("INCLUDE_DIRECTORIES"); + if (!incDirProp) { - qend = currentline.find('\"', qstart+1); + continue; } - // extract the file being included - std::string includeFile = currentline.substr(qstart+1, qend - qstart-1); - // see if the include matches the regular expression - if(!this->IncludeFileRegularExpression.find(includeFile)) + + std::string incDirs = + cmGeneratorExpression::Preprocess(incDirProp, + cmGeneratorExpression::StripAllGeneratorExpressions); + + std::vector<std::string> includes; + cmSystemTools::ExpandListArgument(incDirs, includes); + + for(std::vector<std::string>::const_iterator j = includes.begin(); + j != includes.end(); ++j) { - if(this->Verbose) + std::string path = *j; + this->Makefile->ExpandVariablesInString(path); + if(uniqueIncludes.insert(path).second) { - std::string message = "Skipping "; - message += includeFile; - message += " for file "; - message += info->FullPath.c_str(); - cmSystemTools::Error(message.c_str(), 0); + orderedAndUniqueIncludes.push_back(path); } - continue; } + } - // Add this file and all its dependencies. - this->AddDependency(info, includeFile.c_str()); - /// add the cxx file if it exists - std::string cxxFile = includeFile; - std::string::size_type pos = cxxFile.rfind('.'); - if(pos != std::string::npos) + for(std::vector<std::string>::const_iterator + it = orderedAndUniqueIncludes.begin(); + it != orderedAndUniqueIncludes.end(); + ++it) + { + this->AddSearchPath(*it); + } + } + + /** + * Add a directory to the search path for include files. + */ + void AddSearchPath(const std::string& path) + { + this->IncludeDirectories.push_back(path); + } + + /** + * Generate dependencies for the file given. Returns a pointer to + * the cmDependInformation object for the file. + */ + const cmDependInformation* FindDependencies(const char* file) + { + cmDependInformation* info = this->GetDependInformation(file,0); + this->GenerateDependInformation(info); + return info; + } + +protected: + /** + * Compute the depend information for this class. + */ + + void DependWalk(cmDependInformation* info) + { + cmsys::ifstream fin(info->FullPath.c_str()); + if(!fin) + { + cmSystemTools::Error("error can not open ", info->FullPath.c_str()); + return; + } + + std::string line; + while(cmSystemTools::GetLineFromStream(fin, line)) + { + if(cmHasLiteralPrefix(line.c_str(), "#include")) { - std::string root = cxxFile.substr(0, pos); - cxxFile = root + ".cxx"; - bool found = false; - // try jumping to .cxx .cpp and .c in order - if(cmSystemTools::FileExists(cxxFile.c_str())) + // if it is an include line then create a string class + std::string currentline = line; + size_t qstart = currentline.find('\"', 8); + size_t qend; + // if a quote is not found look for a < + if(qstart == std::string::npos) { - found = true; + qstart = currentline.find('<', 8); + // if a < is not found then move on + if(qstart == std::string::npos) + { + cmSystemTools::Error("unknown include directive ", + currentline.c_str() ); + continue; + } + else + { + qend = currentline.find('>', qstart+1); + } } - for(std::vector<std::string>::iterator i = - this->IncludeDirectories.begin(); - i != this->IncludeDirectories.end(); ++i) + else + { + qend = currentline.find('\"', qstart+1); + } + // extract the file being included + std::string includeFile = + currentline.substr(qstart+1, qend - qstart-1); + // see if the include matches the regular expression + if(!this->IncludeFileRegularExpression.find(includeFile)) { - std::string path = *i; - path = path + "/"; - path = path + cxxFile; - if(cmSystemTools::FileExists(path.c_str())) + if(this->Verbose) { - found = true; + std::string message = "Skipping "; + message += includeFile; + message += " for file "; + message += info->FullPath.c_str(); + cmSystemTools::Error(message.c_str(), 0); } + continue; } - if (!found) + + // Add this file and all its dependencies. + this->AddDependency(info, includeFile.c_str()); + /// add the cxx file if it exists + std::string cxxFile = includeFile; + std::string::size_type pos = cxxFile.rfind('.'); + if(pos != std::string::npos) { - cxxFile = root + ".cpp"; + std::string root = cxxFile.substr(0, pos); + cxxFile = root + ".cxx"; + bool found = false; + // try jumping to .cxx .cpp and .c in order if(cmSystemTools::FileExists(cxxFile.c_str())) { found = true; } for(std::vector<std::string>::iterator i = - this->IncludeDirectories.begin(); + this->IncludeDirectories.begin(); i != this->IncludeDirectories.end(); ++i) { std::string path = *i; @@ -122,55 +253,314 @@ void cmLBDepend::DependWalk(cmDependInformation* info) found = true; } } - } - if (!found) - { - cxxFile = root + ".c"; - if(cmSystemTools::FileExists(cxxFile.c_str())) + if (!found) { - found = true; - } - for(std::vector<std::string>::iterator i = - this->IncludeDirectories.begin(); - i != this->IncludeDirectories.end(); ++i) - { - std::string path = *i; - path = path + "/"; - path = path + cxxFile; - if(cmSystemTools::FileExists(path.c_str())) + cxxFile = root + ".cpp"; + if(cmSystemTools::FileExists(cxxFile.c_str())) { found = true; } + for(std::vector<std::string>::iterator i = + this->IncludeDirectories.begin(); + i != this->IncludeDirectories.end(); ++i) + { + std::string path = *i; + path = path + "/"; + path = path + cxxFile; + if(cmSystemTools::FileExists(path.c_str())) + { + found = true; + } + } } - } - if (!found) - { - cxxFile = root + ".txx"; - if(cmSystemTools::FileExists(cxxFile.c_str())) + if (!found) { - found = true; - } - for(std::vector<std::string>::iterator i = + cxxFile = root + ".c"; + if(cmSystemTools::FileExists(cxxFile.c_str())) + { + found = true; + } + for(std::vector<std::string>::iterator i = this->IncludeDirectories.begin(); - i != this->IncludeDirectories.end(); ++i) + i != this->IncludeDirectories.end(); ++i) + { + std::string path = *i; + path = path + "/"; + path = path + cxxFile; + if(cmSystemTools::FileExists(path.c_str())) + { + found = true; + } + } + } + if (!found) { - std::string path = *i; - path = path + "/"; - path = path + cxxFile; - if(cmSystemTools::FileExists(path.c_str())) + cxxFile = root + ".txx"; + if(cmSystemTools::FileExists(cxxFile.c_str())) { found = true; } + for(std::vector<std::string>::iterator i = + this->IncludeDirectories.begin(); + i != this->IncludeDirectories.end(); ++i) + { + std::string path = *i; + path = path + "/"; + path = path + cxxFile; + if(cmSystemTools::FileExists(path.c_str())) + { + found = true; + } + } + } + if (found) + { + this->AddDependency(info, cxxFile.c_str()); } } - if (found) + } + } + } + + /** + * Add a dependency. Possibly walk it for more dependencies. + */ + void AddDependency(cmDependInformation* info, const char* file) + { + cmDependInformation* dependInfo = + this->GetDependInformation(file, info->PathOnly.c_str()); + this->GenerateDependInformation(dependInfo); + info->AddDependencies(dependInfo); + } + + /** + * Fill in the given object with dependency information. If the + * information is already complete, nothing is done. + */ + void GenerateDependInformation(cmDependInformation* info) + { + // If dependencies are already done, stop now. + if(info->DependDone) + { + return; + } + else + { + // Make sure we don't visit the same file more than once. + info->DependDone = true; + } + const char* path = info->FullPath.c_str(); + if(!path) + { + cmSystemTools::Error( + "Attempt to find dependencies for file without path!"); + return; + } + + bool found = false; + + // If the file exists, use it to find dependency information. + if(cmSystemTools::FileExists(path, true)) + { + // Use the real file to find its dependencies. + this->DependWalk(info); + found = true; + } + + + // See if the cmSourceFile for it has any files specified as + // dependency hints. + if(info->SourceFile != 0) + { + + // Get the cmSourceFile corresponding to this. + const cmSourceFile& cFile = *(info->SourceFile); + // See if there are any hints for finding dependencies for the missing + // file. + if(!cFile.GetDepends().empty()) + { + // Dependency hints have been given. Use them to begin the + // recursion. + for(std::vector<std::string>::const_iterator file = + cFile.GetDepends().begin(); file != cFile.GetDepends().end(); + ++file) { - this->AddDependency(info, cxxFile.c_str()); + this->AddDependency(info, file->c_str()); } + + // Found dependency information. We are done. + found = true; } } - } -} + + if(!found) + { + // Try to find the file amongst the sources + cmSourceFile *srcFile = this->Makefile->GetSource + (cmSystemTools::GetFilenameWithoutExtension(path)); + if (srcFile) + { + if (srcFile->GetFullPath() == path) + { + found=true; + } + else + { + //try to guess which include path to use + for(std::vector<std::string>::iterator t = + this->IncludeDirectories.begin(); + t != this->IncludeDirectories.end(); ++t) + { + std::string incpath = *t; + if (!incpath.empty() && incpath[incpath.size() - 1] != '/') + { + incpath = incpath + "/"; + } + incpath = incpath + path; + if (srcFile->GetFullPath() == incpath) + { + // set the path to the guessed path + info->FullPath = incpath; + found=true; + } + } + } + } + } + + if(!found) + { + // Couldn't find any dependency information. + if(this->ComplainFileRegularExpression.find(info->IncludeName.c_str())) + { + cmSystemTools::Error("error cannot find dependencies for ", path); + } + else + { + // Destroy the name of the file so that it won't be output as a + // dependency. + info->FullPath = ""; + } + } + } + + /** + * Get an instance of cmDependInformation corresponding to the given file + * name. + */ + cmDependInformation* GetDependInformation(const char* file, + const char *extraPath) + { + // Get the full path for the file so that lookup is unambiguous. + std::string fullPath = this->FullPath(file, extraPath); + + // Try to find the file's instance of cmDependInformation. + DependInformationMapType::const_iterator result = + this->DependInformationMap.find(fullPath); + if(result != this->DependInformationMap.end()) + { + // Found an instance, return it. + return result->second; + } + else + { + // Didn't find an instance. Create a new one and save it. + cmDependInformation* info = new cmDependInformation; + info->FullPath = fullPath; + info->PathOnly = cmSystemTools::GetFilenamePath(fullPath); + info->IncludeName = file; + this->DependInformationMap[fullPath] = info; + return info; + } + } + + /** + * Find the full path name for the given file name. + * This uses the include directories. + * TODO: Cache path conversions to reduce FileExists calls. + */ + std::string FullPath(const char *fname, const char *extraPath) + { + DirectoryToFileToPathMapType::iterator m; + if(extraPath) + { + m = this->DirectoryToFileToPathMap.find(extraPath); + } + else + { + m = this->DirectoryToFileToPathMap.find(""); + } + + if(m != this->DirectoryToFileToPathMap.end()) + { + FileToPathMapType& map = m->second; + FileToPathMapType::iterator p = map.find(fname); + if(p != map.end()) + { + return p->second; + } + } + + if(cmSystemTools::FileExists(fname, true)) + { + std::string fp = cmSystemTools::CollapseFullPath(fname); + this->DirectoryToFileToPathMap[extraPath? extraPath: ""][fname] = fp; + return fp; + } + + for(std::vector<std::string>::iterator i = + this->IncludeDirectories.begin(); + i != this->IncludeDirectories.end(); ++i) + { + std::string path = *i; + if (!path.empty() && path[path.size() - 1] != '/') + { + path = path + "/"; + } + path = path + fname; + if(cmSystemTools::FileExists(path.c_str(), true) + && !cmSystemTools::FileIsDirectory(path)) + { + std::string fp = cmSystemTools::CollapseFullPath(path); + this->DirectoryToFileToPathMap[extraPath? extraPath: ""][fname] = fp; + return fp; + } + } + + if (extraPath) + { + std::string path = extraPath; + if (!path.empty() && path[path.size() - 1] != '/') + { + path = path + "/"; + } + path = path + fname; + if(cmSystemTools::FileExists(path.c_str(), true) + && !cmSystemTools::FileIsDirectory(path)) + { + std::string fp = cmSystemTools::CollapseFullPath(path); + this->DirectoryToFileToPathMap[extraPath][fname] = fp; + return fp; + } + } + + // Couldn't find the file. + return std::string(fname); + } + + cmMakefile* Makefile; + bool Verbose; + cmsys::RegularExpression IncludeFileRegularExpression; + cmsys::RegularExpression ComplainFileRegularExpression; + std::vector<std::string> IncludeDirectories; + typedef std::map<std::string, std::string> FileToPathMapType; + typedef std::map<std::string, FileToPathMapType> + DirectoryToFileToPathMapType; + typedef std::map<std::string, cmDependInformation*> + DependInformationMapType; + DependInformationMapType DependInformationMap; + DirectoryToFileToPathMapType DirectoryToFileToPathMap; +}; // cmOutputRequiredFilesCommand bool cmOutputRequiredFilesCommand diff --git a/Source/cmOutputRequiredFilesCommand.h b/Source/cmOutputRequiredFilesCommand.h index 6a09673..b5eb932 100644 --- a/Source/cmOutputRequiredFilesCommand.h +++ b/Source/cmOutputRequiredFilesCommand.h @@ -13,7 +13,8 @@ #define cmOutputRequiredFilesCommand_h #include "cmCommand.h" -#include "cmMakeDepend.h" + +class cmDependInformation; class cmOutputRequiredFilesCommand : public cmCommand { diff --git a/Source/cmPolicies.h b/Source/cmPolicies.h index a549d18..5023055 100644 --- a/Source/cmPolicies.h +++ b/Source/cmPolicies.h @@ -230,6 +230,23 @@ class cmPolicy; #define CM_FOR_EACH_POLICY_ID(POLICY) \ CM_FOR_EACH_POLICY_TABLE(POLICY, CM_SELECT_ID) +#define CM_FOR_EACH_TARGET_POLICY(F) \ + F(CMP0003) \ + F(CMP0004) \ + F(CMP0008) \ + F(CMP0020) \ + F(CMP0021) \ + F(CMP0022) \ + F(CMP0027) \ + F(CMP0038) \ + F(CMP0041) \ + F(CMP0042) \ + F(CMP0046) \ + F(CMP0052) \ + F(CMP0060) \ + F(CMP0063) \ + F(CMP0065) + /** \class cmPolicies * \brief Handles changes in CMake behavior and policies diff --git a/Source/cmQtAutoGeneratorInitializer.cxx b/Source/cmQtAutoGeneratorInitializer.cxx index d52ab78..08caea3 100644 --- a/Source/cmQtAutoGeneratorInitializer.cxx +++ b/Source/cmQtAutoGeneratorInitializer.cxx @@ -25,22 +25,430 @@ # include "cmGlobalVisualStudioGenerator.h" #endif -std::string cmQtAutoGeneratorInitializer::GetAutogenTargetName( - cmTarget const* target) +static void SetupSourceFiles(cmGeneratorTarget const* target, + std::vector<std::string>& skipMoc, + std::vector<std::string>& mocSources, + std::vector<std::string>& mocHeaders, + std::vector<std::string>& skipUic) +{ + cmMakefile* makefile = target->Target->GetMakefile(); + + std::vector<cmSourceFile*> srcFiles; + target->GetConfigCommonSourceFiles(srcFiles); + + std::vector<std::string> newRccFiles; + + for(std::vector<cmSourceFile*>::const_iterator fileIt = srcFiles.begin(); + fileIt != srcFiles.end(); + ++fileIt) + { + cmSourceFile* sf = *fileIt; + std::string absFile = cmsys::SystemTools::GetRealPath( + sf->GetFullPath()); + bool skipFileForMoc = + cmSystemTools::IsOn(sf->GetPropertyForUser("SKIP_AUTOMOC")); + bool generated = cmSystemTools::IsOn(sf->GetPropertyForUser("GENERATED")); + + if(cmSystemTools::IsOn(sf->GetPropertyForUser("SKIP_AUTOUIC"))) + { + skipUic.push_back(absFile); + } + + std::string ext = sf->GetExtension(); + + if (target->GetPropertyAsBool("AUTORCC")) + { + if (ext == "qrc" + && !cmSystemTools::IsOn(sf->GetPropertyForUser("SKIP_AUTORCC"))) + { + std::string basename = cmsys::SystemTools:: + GetFilenameWithoutLastExtension(absFile); + + std::string rcc_output_dir = target->GetSupportDirectory(); + cmSystemTools::MakeDirectory(rcc_output_dir.c_str()); + std::string rcc_output_file = rcc_output_dir; + rcc_output_file += "/qrc_" + basename + ".cpp"; + makefile->AppendProperty("ADDITIONAL_MAKE_CLEAN_FILES", + rcc_output_file.c_str(), false); + makefile->GetOrCreateSource(rcc_output_file, true); + newRccFiles.push_back(rcc_output_file); + } + } + + if (!generated) + { + if (skipFileForMoc) + { + skipMoc.push_back(absFile); + } + else + { + cmSystemTools::FileFormat fileType = cmSystemTools::GetFileFormat( + ext.c_str()); + if (fileType == cmSystemTools::CXX_FILE_FORMAT) + { + mocSources.push_back(absFile); + } + else if (fileType == cmSystemTools::HEADER_FILE_FORMAT) + { + mocHeaders.push_back(absFile); + } + } + } + } + + for(std::vector<std::string>::const_iterator fileIt = newRccFiles.begin(); + fileIt != newRccFiles.end(); + ++fileIt) + { + const_cast<cmGeneratorTarget*>(target)->AddSource(*fileIt); + } +} + +static void GetCompileDefinitionsAndDirectories( + cmGeneratorTarget const* target, + const std::string& config, + std::string &incs, + std::string &defs) +{ + std::vector<std::string> includeDirs; + cmLocalGenerator *localGen = target->GetLocalGenerator(); + // Get the include dirs for this target, without stripping the implicit + // include dirs off, see http://public.kitware.com/Bug/view.php?id=13667 + localGen->GetIncludeDirectories(includeDirs, target, "CXX", config, false); + + incs = cmJoin(includeDirs, ";"); + + std::set<std::string> defines; + localGen->AddCompileDefinitions(defines, target, config, "CXX"); + + defs += cmJoin(defines, ";"); +} + +static void SetupAutoMocTarget(cmGeneratorTarget const* target, + const std::string &autogenTargetName, + std::vector<std::string> const& skipMoc, + std::vector<std::string> const& mocHeaders, + std::map<std::string, std::string> &configIncludes, + std::map<std::string, std::string> &configDefines) +{ + cmLocalGenerator* lg = target->GetLocalGenerator(); + cmMakefile* makefile = target->Target->GetMakefile(); + + const char* tmp = target->GetProperty("AUTOMOC_MOC_OPTIONS"); + std::string _moc_options = (tmp!=0 ? tmp : ""); + makefile->AddDefinition("_moc_options", + cmOutputConverter::EscapeForCMake(_moc_options).c_str()); + makefile->AddDefinition("_skip_moc", + cmOutputConverter::EscapeForCMake(cmJoin(skipMoc, ";")).c_str()); + makefile->AddDefinition("_moc_headers", + cmOutputConverter::EscapeForCMake(cmJoin(mocHeaders, ";")).c_str()); + bool relaxedMode = makefile->IsOn("CMAKE_AUTOMOC_RELAXED_MODE"); + makefile->AddDefinition("_moc_relaxed_mode", relaxedMode ? "TRUE" : "FALSE"); + + std::string _moc_incs; + std::string _moc_compile_defs; + std::vector<std::string> configs; + const std::string& config = makefile->GetConfigurations(configs); + GetCompileDefinitionsAndDirectories(target, config, + _moc_incs, _moc_compile_defs); + + makefile->AddDefinition("_moc_incs", + cmOutputConverter::EscapeForCMake(_moc_incs).c_str()); + makefile->AddDefinition("_moc_compile_defs", + cmOutputConverter::EscapeForCMake(_moc_compile_defs).c_str()); + + for (std::vector<std::string>::const_iterator li = configs.begin(); + li != configs.end(); ++li) + { + std::string config_moc_incs; + std::string config_moc_compile_defs; + GetCompileDefinitionsAndDirectories(target, *li, + config_moc_incs, + config_moc_compile_defs); + if (config_moc_incs != _moc_incs) + { + configIncludes[*li] = + cmOutputConverter::EscapeForCMake(config_moc_incs); + if(_moc_incs.empty()) + { + _moc_incs = config_moc_incs; + } + } + if (config_moc_compile_defs != _moc_compile_defs) + { + configDefines[*li] = + cmOutputConverter::EscapeForCMake(config_moc_compile_defs); + if(_moc_compile_defs.empty()) + { + _moc_compile_defs = config_moc_compile_defs; + } + } + } + + const char *qtVersion = makefile->GetDefinition("_target_qt_version"); + if (strcmp(qtVersion, "5") == 0) + { + cmGeneratorTarget *qt5Moc = + lg->FindGeneratorTargetToUse("Qt5::moc"); + if (!qt5Moc) + { + cmSystemTools::Error("Qt5::moc target not found ", + autogenTargetName.c_str()); + return; + } + makefile->AddDefinition("_qt_moc_executable", + qt5Moc->ImportedGetLocation("")); + } + else if (strcmp(qtVersion, "4") == 0) + { + cmGeneratorTarget *qt4Moc = + lg->FindGeneratorTargetToUse("Qt4::moc"); + if (!qt4Moc) + { + cmSystemTools::Error("Qt4::moc target not found ", + autogenTargetName.c_str()); + return; + } + makefile->AddDefinition("_qt_moc_executable", + qt4Moc->ImportedGetLocation("")); + } + else + { + cmSystemTools::Error("The CMAKE_AUTOMOC feature supports only Qt 4 and " + "Qt 5 ", autogenTargetName.c_str()); + } +} + +static void GetUicOpts(cmGeneratorTarget const* target, + const std::string& config, + std::string &optString) +{ + std::vector<std::string> opts; + target->GetAutoUicOptions(opts, config); + optString = cmJoin(opts, ";"); +} + +static void SetupAutoUicTarget(cmGeneratorTarget const* target, + std::vector<std::string> const& skipUic, + std::map<std::string, std::string> &configUicOptions) +{ + cmLocalGenerator* lg = target->GetLocalGenerator(); + cmMakefile *makefile = target->Target->GetMakefile(); + + std::set<std::string> skipped; + skipped.insert(skipUic.begin(), skipUic.end()); + + makefile->AddDefinition("_skip_uic", + cmOutputConverter::EscapeForCMake(cmJoin(skipUic, ";")).c_str()); + + std::vector<cmSourceFile*> uiFilesWithOptions + = makefile->GetQtUiFilesWithOptions(); + + const char *qtVersion = makefile->GetDefinition("_target_qt_version"); + + std::string _uic_opts; + std::vector<std::string> configs; + const std::string& config = makefile->GetConfigurations(configs); + GetUicOpts(target, config, _uic_opts); + + if (!_uic_opts.empty()) + { + _uic_opts = cmOutputConverter::EscapeForCMake(_uic_opts); + makefile->AddDefinition("_uic_target_options", _uic_opts.c_str()); + } + for (std::vector<std::string>::const_iterator li = configs.begin(); + li != configs.end(); ++li) + { + std::string config_uic_opts; + GetUicOpts(target, *li, config_uic_opts); + if (config_uic_opts != _uic_opts) + { + configUicOptions[*li] = + cmOutputConverter::EscapeForCMake(config_uic_opts); + if(_uic_opts.empty()) + { + _uic_opts = config_uic_opts; + } + } + } + + std::string uiFileFiles; + std::string uiFileOptions; + const char* sep = ""; + + for(std::vector<cmSourceFile*>::const_iterator fileIt = + uiFilesWithOptions.begin(); + fileIt != uiFilesWithOptions.end(); + ++fileIt) + { + cmSourceFile* sf = *fileIt; + std::string absFile = cmsys::SystemTools::GetRealPath( + sf->GetFullPath()); + + if (!skipped.insert(absFile).second) + { + continue; + } + uiFileFiles += sep; + uiFileFiles += absFile; + uiFileOptions += sep; + std::string opts = sf->GetProperty("AUTOUIC_OPTIONS"); + cmSystemTools::ReplaceString(opts, ";", "@list_sep@"); + uiFileOptions += opts; + sep = ";"; + } + + makefile->AddDefinition("_qt_uic_options_files", + cmOutputConverter::EscapeForCMake(uiFileFiles).c_str()); + makefile->AddDefinition("_qt_uic_options_options", + cmOutputConverter::EscapeForCMake(uiFileOptions).c_str()); + + std::string targetName = target->GetName(); + if (strcmp(qtVersion, "5") == 0) + { + cmGeneratorTarget *qt5Uic = + lg->FindGeneratorTargetToUse("Qt5::uic"); + if (!qt5Uic) + { + // Project does not use Qt5Widgets, but has AUTOUIC ON anyway + } + else + { + makefile->AddDefinition("_qt_uic_executable", + qt5Uic->ImportedGetLocation("")); + } + } + else if (strcmp(qtVersion, "4") == 0) + { + cmGeneratorTarget *qt4Uic = + lg->FindGeneratorTargetToUse("Qt4::uic"); + if (!qt4Uic) + { + cmSystemTools::Error("Qt4::uic target not found ", + targetName.c_str()); + return; + } + makefile->AddDefinition("_qt_uic_executable", + qt4Uic->ImportedGetLocation("")); + } + else + { + cmSystemTools::Error("The CMAKE_AUTOUIC feature supports only Qt 4 and " + "Qt 5 ", targetName.c_str()); + } +} + +static std::string GetRccExecutable(cmGeneratorTarget const* target) +{ + cmLocalGenerator* lg = target->GetLocalGenerator(); + cmMakefile *makefile = target->Target->GetMakefile(); + const char *qtVersion = makefile->GetDefinition("_target_qt_version"); + if (!qtVersion) + { + qtVersion = makefile->GetDefinition("Qt5Core_VERSION_MAJOR"); + if (!qtVersion) + { + qtVersion = makefile->GetDefinition("QT_VERSION_MAJOR"); + } + if (const char *targetQtVersion = + target->GetLinkInterfaceDependentStringProperty("QT_MAJOR_VERSION", + "")) + { + qtVersion = targetQtVersion; + } + } + + std::string targetName = target->GetName(); + if (strcmp(qtVersion, "5") == 0) + { + cmGeneratorTarget *qt5Rcc = + lg->FindGeneratorTargetToUse("Qt5::rcc"); + if (!qt5Rcc) + { + cmSystemTools::Error("Qt5::rcc target not found ", + targetName.c_str()); + return std::string(); + } + return qt5Rcc->ImportedGetLocation(""); + } + else if (strcmp(qtVersion, "4") == 0) + { + cmGeneratorTarget *qt4Rcc = + lg->FindGeneratorTargetToUse("Qt4::rcc"); + if (!qt4Rcc) + { + cmSystemTools::Error("Qt4::rcc target not found ", + targetName.c_str()); + return std::string(); + } + return qt4Rcc->ImportedGetLocation(""); + } + + cmSystemTools::Error("The CMAKE_AUTORCC feature supports only Qt 4 and " + "Qt 5 ", targetName.c_str()); + return std::string(); +} + +static void MergeRccOptions(std::vector<std::string> &opts, + const std::vector<std::string> &fileOpts, + bool isQt5) +{ + static const char* valueOptions[] = { + "name", + "root", + "compress", + "threshold" + }; + std::vector<std::string> extraOpts; + for(std::vector<std::string>::const_iterator it = fileOpts.begin(); + it != fileOpts.end(); ++it) + { + std::vector<std::string>::iterator existingIt + = std::find(opts.begin(), opts.end(), *it); + if (existingIt != opts.end()) + { + const char *o = it->c_str(); + if (*o == '-') + { + ++o; + } + if (isQt5 && *o == '-') + { + ++o; + } + if (std::find_if(cmArrayBegin(valueOptions), cmArrayEnd(valueOptions), + cmStrCmp(*it)) != cmArrayEnd(valueOptions)) + { + assert(existingIt + 1 != opts.end()); + *(existingIt + 1) = *(it + 1); + ++it; + } + } + else + { + extraOpts.push_back(*it); + } + } + opts.insert(opts.end(), extraOpts.begin(), extraOpts.end()); +} + +std::string GetAutogenTargetName( + cmGeneratorTarget const* target) { std::string autogenTargetName = target->GetName(); autogenTargetName += "_automoc"; return autogenTargetName; } -std::string cmQtAutoGeneratorInitializer::GetAutogenTargetDir( - cmTarget const* target) +std::string GetAutogenTargetDir( + cmGeneratorTarget const* target) { - cmMakefile* makefile = target->GetMakefile(); + cmMakefile* makefile = target->Target->GetMakefile(); std::string targetDir = makefile->GetCurrentBinaryDirectory(); targetDir += makefile->GetCMakeInstance()->GetCMakeFilesDirectory(); targetDir += "/"; - targetDir += cmQtAutoGeneratorInitializer::GetAutogenTargetName(target); + targetDir += GetAutogenTargetName(target); targetDir += ".dir/"; return targetDir; } @@ -76,17 +484,36 @@ static std::string ReadAll(const std::string& filename) return stream.str(); } -std::string cmQtAutoGeneratorInitializer::ListQt5RccInputs(cmSourceFile* sf, - cmTarget const* target, +static std::string ListQt5RccInputs(cmSourceFile* sf, + cmGeneratorTarget const* target, std::vector<std::string>& depends) { std::string rccCommand - = cmQtAutoGeneratorInitializer::GetRccExecutable(target); + = GetRccExecutable(target); + + bool hasDashDashList = false; + { + std::vector<std::string> command; + command.push_back(rccCommand); + command.push_back("--help"); + std::string rccStdOut; + std::string rccStdErr; + int retVal = 0; + bool result = cmSystemTools::RunSingleCommand( + command, &rccStdOut, &rccStdErr, + &retVal, 0, cmSystemTools::OUTPUT_NONE); + if (result && retVal == 0 && + rccStdOut.find("--list") != std::string::npos) + { + hasDashDashList = true; + } + } + std::vector<std::string> qrcEntries; std::vector<std::string> command; command.push_back(rccCommand); - command.push_back("--list"); + command.push_back(hasDashDashList? "--list" : "-list"); std::string absFile = cmsys::SystemTools::GetRealPath( sf->GetFullPath()); @@ -147,7 +574,7 @@ std::string cmQtAutoGeneratorInitializer::ListQt5RccInputs(cmSourceFile* sf, return cmJoin(qrcEntries, "@list_sep@"); } -std::string cmQtAutoGeneratorInitializer::ListQt4RccInputs(cmSourceFile* sf, +static std::string ListQt4RccInputs(cmSourceFile* sf, std::vector<std::string>& depends) { const std::string qrcContents = ReadAll(sf->GetFullPath()); @@ -183,15 +610,125 @@ std::string cmQtAutoGeneratorInitializer::ListQt4RccInputs(cmSourceFile* sf, return entriesList; } +static void SetupAutoRccTarget(cmGeneratorTarget const* target) +{ + std::string _rcc_files; + const char* sepRccFiles = ""; + cmMakefile *makefile = target->Target->GetMakefile(); + + std::vector<cmSourceFile*> srcFiles; + target->GetConfigCommonSourceFiles(srcFiles); + + std::string qrcInputs; + const char* qrcInputsSep = ""; + + std::string rccFileFiles; + std::string rccFileOptions; + const char *optionSep = ""; + + const char *qtVersion = makefile->GetDefinition("_target_qt_version"); + + std::vector<std::string> rccOptions; + if (const char* opts = target->GetProperty("AUTORCC_OPTIONS")) + { + cmSystemTools::ExpandListArgument(opts, rccOptions); + } + std::string qtMajorVersion = makefile->GetSafeDefinition("QT_VERSION_MAJOR"); + if (qtMajorVersion == "") + { + qtMajorVersion = makefile->GetSafeDefinition("Qt5Core_VERSION_MAJOR"); + } + + for(std::vector<cmSourceFile*>::const_iterator fileIt = srcFiles.begin(); + fileIt != srcFiles.end(); + ++fileIt) + { + cmSourceFile* sf = *fileIt; + std::string ext = sf->GetExtension(); + if (ext == "qrc") + { + std::string absFile = cmsys::SystemTools::GetRealPath( + sf->GetFullPath()); + bool skip = cmSystemTools::IsOn(sf->GetPropertyForUser("SKIP_AUTORCC")); + + if (!skip) + { + _rcc_files += sepRccFiles; + _rcc_files += absFile; + sepRccFiles = ";"; + + if (const char *prop = sf->GetProperty("AUTORCC_OPTIONS")) + { + std::vector<std::string> optsVec; + cmSystemTools::ExpandListArgument(prop, optsVec); + MergeRccOptions(rccOptions, optsVec, + strcmp(qtVersion, "5") == 0); + } + + if (!rccOptions.empty()) + { + rccFileFiles += optionSep; + rccFileFiles += absFile; + rccFileOptions += optionSep; + } + const char *listSep = ""; + for(std::vector<std::string>::const_iterator it = rccOptions.begin(); + it != rccOptions.end(); + ++it) + { + rccFileOptions += listSep; + rccFileOptions += *it; + listSep = "@list_sep@"; + } + optionSep = ";"; + + std::vector<std::string> depends; + + std::string entriesList; + if (!cmSystemTools::IsOn(sf->GetPropertyForUser("GENERATED"))) + { + if (qtMajorVersion == "5") + { + entriesList = ListQt5RccInputs(sf, target, depends); + } + else + { + entriesList = ListQt4RccInputs(sf, depends); + } + if (entriesList.empty()) + { + return; + } + } + qrcInputs += qrcInputsSep; + qrcInputs += entriesList; + qrcInputsSep = ";"; + } + } + } + makefile->AddDefinition("_qt_rcc_inputs_" + target->GetName(), + cmOutputConverter::EscapeForCMake(qrcInputs).c_str()); + + makefile->AddDefinition("_rcc_files", + cmOutputConverter::EscapeForCMake(_rcc_files).c_str()); -void cmQtAutoGeneratorInitializer::InitializeAutogenSources(cmTarget* target) + makefile->AddDefinition("_qt_rcc_options_files", + cmOutputConverter::EscapeForCMake(rccFileFiles).c_str()); + makefile->AddDefinition("_qt_rcc_options_options", + cmOutputConverter::EscapeForCMake(rccFileOptions).c_str()); + + makefile->AddDefinition("_qt_rcc_executable", + GetRccExecutable(target).c_str()); +} + +void cmQtAutoGeneratorInitializer::InitializeAutogenSources( + cmGeneratorTarget* target) { - cmMakefile* makefile = target->GetMakefile(); + cmMakefile* makefile = target->Target->GetMakefile(); if (target->GetPropertyAsBool("AUTOMOC")) { - std::string automocTargetName = - cmQtAutoGeneratorInitializer::GetAutogenTargetName(target); + std::string automocTargetName = GetAutogenTargetName(target); std::string mocCppFile = makefile->GetCurrentBinaryDirectory(); mocCppFile += "/"; mocCppFile += automocTargetName; @@ -206,9 +743,9 @@ void cmQtAutoGeneratorInitializer::InitializeAutogenSources(cmTarget* target) void cmQtAutoGeneratorInitializer::InitializeAutogenTarget( cmLocalGenerator* lg, - cmTarget* target) + cmGeneratorTarget* target) { - cmMakefile* makefile = target->GetMakefile(); + cmMakefile* makefile = target->Target->GetMakefile(); std::string qtMajorVersion = makefile->GetSafeDefinition("QT_VERSION_MAJOR"); if (qtMajorVersion == "") @@ -217,11 +754,9 @@ void cmQtAutoGeneratorInitializer::InitializeAutogenTarget( } // create a custom target for running generators at buildtime: - std::string autogenTargetName = - cmQtAutoGeneratorInitializer::GetAutogenTargetName(target); + std::string autogenTargetName = GetAutogenTargetName(target); - std::string targetDir = - cmQtAutoGeneratorInitializer::GetAutogenTargetDir(target); + std::string targetDir = GetAutogenTargetDir(target); cmCustomCommandLine currentLine; currentLine.push_back(cmSystemTools::GetCMakeCommand()); @@ -307,9 +842,7 @@ void cmQtAutoGeneratorInitializer::InitializeAutogenTarget( ) { std::vector<cmSourceFile*> srcFiles; - cmGeneratorTarget* gtgt = - lg->GetGlobalGenerator()->GetGeneratorTarget(target); - gtgt->GetConfigCommonSourceFiles(srcFiles); + target->GetConfigCommonSourceFiles(srcFiles); for(std::vector<cmSourceFile*>::const_iterator fileIt = srcFiles.begin(); fileIt != srcFiles.end(); ++fileIt) @@ -338,12 +871,11 @@ void cmQtAutoGeneratorInitializer::InitializeAutogenTarget( { if (qtMajorVersion == "5") { - cmQtAutoGeneratorInitializer::ListQt5RccInputs(sf, target, - depends); + ListQt5RccInputs(sf, target, depends); } else { - cmQtAutoGeneratorInitializer::ListQt4RccInputs(sf, depends); + ListQt4RccInputs(sf, depends); } #if defined(_WIN32) && !defined(__CYGWIN__) // Cannot use PRE_BUILD because the resource files themselves @@ -370,7 +902,7 @@ void cmQtAutoGeneratorInitializer::InitializeAutogenTarget( workingDirectory.c_str()); cc.SetEscapeOldStyle(false); cc.SetEscapeAllowMakeVars(true); - target->AddPreBuildCommand(cc); + target->Target->AddPreBuildCommand(cc); } else #endif @@ -382,7 +914,7 @@ void cmQtAutoGeneratorInitializer::InitializeAutogenTarget( commandLines, false, autogenComment.c_str()); cmGeneratorTarget* gt = new cmGeneratorTarget(autogenTarget, lg); - makefile->AddGeneratorTarget(autogenTarget, gt); + lg->AddGeneratorTarget(gt); // Set target folder const char* autogenFolder = makefile->GetState() @@ -399,66 +931,39 @@ void cmQtAutoGeneratorInitializer::InitializeAutogenTarget( else { // inherit FOLDER property from target (#13688) - copyTargetProperty(autogenTarget, target, "FOLDER"); + copyTargetProperty(gt->Target, target->Target, "FOLDER"); } - target->AddUtility(autogenTargetName); + target->Target->AddUtility(autogenTargetName); } } -static void GetCompileDefinitionsAndDirectories(cmTarget const* target, - const std::string& config, - std::string &incs, - std::string &defs) -{ - cmMakefile* makefile = target->GetMakefile(); - cmGlobalGenerator* globalGen = makefile->GetGlobalGenerator(); - std::vector<std::string> includeDirs; - cmGeneratorTarget *gtgt = globalGen->GetGeneratorTarget(target); - cmLocalGenerator *localGen = gtgt->GetLocalGenerator(); - // Get the include dirs for this target, without stripping the implicit - // include dirs off, see http://public.kitware.com/Bug/view.php?id=13667 - localGen->GetIncludeDirectories(includeDirs, gtgt, "CXX", config, false); - - incs = cmJoin(includeDirs, ";"); - - std::set<std::string> defines; - localGen->AddCompileDefinitions(defines, target, config, "CXX"); - - defs += cmJoin(defines, ";"); -} - void cmQtAutoGeneratorInitializer::SetupAutoGenerateTarget( - cmTarget const* target) + cmGeneratorTarget const* target) { - cmMakefile* makefile = target->GetMakefile(); + cmMakefile* makefile = target->Target->GetMakefile(); // forget the variables added here afterwards again: cmMakefile::ScopePushPop varScope(makefile); static_cast<void>(varScope); // create a custom target for running generators at buildtime: - std::string autogenTargetName = - cmQtAutoGeneratorInitializer::GetAutogenTargetName(target); + std::string autogenTargetName = GetAutogenTargetName(target); makefile->AddDefinition("_moc_target_name", cmOutputConverter::EscapeForCMake(autogenTargetName).c_str()); makefile->AddDefinition("_origin_target_name", cmOutputConverter::EscapeForCMake(target->GetName()).c_str()); - std::string targetDir = - cmQtAutoGeneratorInitializer::GetAutogenTargetDir(target); + std::string targetDir = GetAutogenTargetDir(target); const char *qtVersion = makefile->GetDefinition("Qt5Core_VERSION_MAJOR"); if (!qtVersion) { qtVersion = makefile->GetDefinition("QT_VERSION_MAJOR"); } - cmGeneratorTarget *gtgt = target->GetMakefile() - ->GetGlobalGenerator() - ->GetGeneratorTarget(target); if (const char *targetQtVersion = - gtgt->GetLinkInterfaceDependentStringProperty("QT_MAJOR_VERSION", "")) + target->GetLinkInterfaceDependentStringProperty("QT_MAJOR_VERSION", "")) { qtVersion = targetQtVersion; } @@ -479,25 +984,23 @@ void cmQtAutoGeneratorInitializer::SetupAutoGenerateTarget( || target->GetPropertyAsBool("AUTOUIC") || target->GetPropertyAsBool("AUTORCC")) { - cmQtAutoGeneratorInitializer::SetupSourceFiles(target, skipMoc, - mocSources, mocHeaders, skipUic); + SetupSourceFiles(target, skipMoc, mocSources, mocHeaders, skipUic); } makefile->AddDefinition("_cpp_files", cmOutputConverter::EscapeForCMake(cmJoin(mocSources, ";")).c_str()); if (target->GetPropertyAsBool("AUTOMOC")) { - cmQtAutoGeneratorInitializer::SetupAutoMocTarget(target, autogenTargetName, + SetupAutoMocTarget(target, autogenTargetName, skipMoc, mocHeaders, configIncludes, configDefines); } if (target->GetPropertyAsBool("AUTOUIC")) { - cmQtAutoGeneratorInitializer::SetupAutoUicTarget(target, skipUic, - configUicOptions); + SetupAutoUicTarget(target, skipUic, configUicOptions); } if (target->GetPropertyAsBool("AUTORCC")) { - cmQtAutoGeneratorInitializer::SetupAutoRccTarget(target); + SetupAutoRccTarget(target); } const char* cmakeRoot = makefile->GetSafeDefinition("CMAKE_ROOT"); @@ -567,508 +1070,3 @@ void cmQtAutoGeneratorInitializer::SetupAutoGenerateTarget( } } } - -void cmQtAutoGeneratorInitializer::SetupSourceFiles(cmTarget const* target, - std::vector<std::string>& skipMoc, - std::vector<std::string>& mocSources, - std::vector<std::string>& mocHeaders, - std::vector<std::string>& skipUic) -{ - cmMakefile* makefile = target->GetMakefile(); - - std::vector<cmSourceFile*> srcFiles; - cmGeneratorTarget *gtgt = target->GetMakefile() - ->GetGlobalGenerator() - ->GetGeneratorTarget(target); - gtgt->GetConfigCommonSourceFiles(srcFiles); - - std::vector<std::string> newRccFiles; - - for(std::vector<cmSourceFile*>::const_iterator fileIt = srcFiles.begin(); - fileIt != srcFiles.end(); - ++fileIt) - { - cmSourceFile* sf = *fileIt; - std::string absFile = cmsys::SystemTools::GetRealPath( - sf->GetFullPath()); - bool skipFileForMoc = - cmSystemTools::IsOn(sf->GetPropertyForUser("SKIP_AUTOMOC")); - bool generated = cmSystemTools::IsOn(sf->GetPropertyForUser("GENERATED")); - - if(cmSystemTools::IsOn(sf->GetPropertyForUser("SKIP_AUTOUIC"))) - { - skipUic.push_back(absFile); - } - - std::string ext = sf->GetExtension(); - - if (target->GetPropertyAsBool("AUTORCC")) - { - if (ext == "qrc" - && !cmSystemTools::IsOn(sf->GetPropertyForUser("SKIP_AUTORCC"))) - { - std::string basename = cmsys::SystemTools:: - GetFilenameWithoutLastExtension(absFile); - - std::string rcc_output_dir = target->GetSupportDirectory(); - cmSystemTools::MakeDirectory(rcc_output_dir.c_str()); - std::string rcc_output_file = rcc_output_dir; - rcc_output_file += "/qrc_" + basename + ".cpp"; - makefile->AppendProperty("ADDITIONAL_MAKE_CLEAN_FILES", - rcc_output_file.c_str(), false); - makefile->GetOrCreateSource(rcc_output_file, true); - newRccFiles.push_back(rcc_output_file); - } - } - - if (!generated) - { - if (skipFileForMoc) - { - skipMoc.push_back(absFile); - } - else - { - cmSystemTools::FileFormat fileType = cmSystemTools::GetFileFormat( - ext.c_str()); - if (fileType == cmSystemTools::CXX_FILE_FORMAT) - { - mocSources.push_back(absFile); - } - else if (fileType == cmSystemTools::HEADER_FILE_FORMAT) - { - mocHeaders.push_back(absFile); - } - } - } - } - - for(std::vector<std::string>::const_iterator fileIt = newRccFiles.begin(); - fileIt != newRccFiles.end(); - ++fileIt) - { - const_cast<cmTarget*>(target)->AddSource(*fileIt); - } -} - -void cmQtAutoGeneratorInitializer::SetupAutoMocTarget(cmTarget const* target, - const std::string &autogenTargetName, - std::vector<std::string> const& skipMoc, - std::vector<std::string> const& mocHeaders, - std::map<std::string, std::string> &configIncludes, - std::map<std::string, std::string> &configDefines) -{ - cmMakefile* makefile = target->GetMakefile(); - - const char* tmp = target->GetProperty("AUTOMOC_MOC_OPTIONS"); - std::string _moc_options = (tmp!=0 ? tmp : ""); - makefile->AddDefinition("_moc_options", - cmOutputConverter::EscapeForCMake(_moc_options).c_str()); - makefile->AddDefinition("_skip_moc", - cmOutputConverter::EscapeForCMake(cmJoin(skipMoc, ";")).c_str()); - makefile->AddDefinition("_moc_headers", - cmOutputConverter::EscapeForCMake(cmJoin(mocHeaders, ";")).c_str()); - bool relaxedMode = makefile->IsOn("CMAKE_AUTOMOC_RELAXED_MODE"); - makefile->AddDefinition("_moc_relaxed_mode", relaxedMode ? "TRUE" : "FALSE"); - - std::string _moc_incs; - std::string _moc_compile_defs; - std::vector<std::string> configs; - const std::string& config = makefile->GetConfigurations(configs); - GetCompileDefinitionsAndDirectories(target, config, - _moc_incs, _moc_compile_defs); - - makefile->AddDefinition("_moc_incs", - cmOutputConverter::EscapeForCMake(_moc_incs).c_str()); - makefile->AddDefinition("_moc_compile_defs", - cmOutputConverter::EscapeForCMake(_moc_compile_defs).c_str()); - - for (std::vector<std::string>::const_iterator li = configs.begin(); - li != configs.end(); ++li) - { - std::string config_moc_incs; - std::string config_moc_compile_defs; - GetCompileDefinitionsAndDirectories(target, *li, - config_moc_incs, - config_moc_compile_defs); - if (config_moc_incs != _moc_incs) - { - configIncludes[*li] = - cmOutputConverter::EscapeForCMake(config_moc_incs); - if(_moc_incs.empty()) - { - _moc_incs = config_moc_incs; - } - } - if (config_moc_compile_defs != _moc_compile_defs) - { - configDefines[*li] = - cmOutputConverter::EscapeForCMake(config_moc_compile_defs); - if(_moc_compile_defs.empty()) - { - _moc_compile_defs = config_moc_compile_defs; - } - } - } - - const char *qtVersion = makefile->GetDefinition("_target_qt_version"); - if (strcmp(qtVersion, "5") == 0) - { - cmTarget *qt5Moc = makefile->FindTargetToUse("Qt5::moc"); - if (!qt5Moc) - { - cmSystemTools::Error("Qt5::moc target not found ", - autogenTargetName.c_str()); - return; - } - makefile->AddDefinition("_qt_moc_executable", - qt5Moc->ImportedGetLocation("")); - } - else if (strcmp(qtVersion, "4") == 0) - { - cmTarget *qt4Moc = makefile->FindTargetToUse("Qt4::moc"); - if (!qt4Moc) - { - cmSystemTools::Error("Qt4::moc target not found ", - autogenTargetName.c_str()); - return; - } - makefile->AddDefinition("_qt_moc_executable", - qt4Moc->ImportedGetLocation("")); - } - else - { - cmSystemTools::Error("The CMAKE_AUTOMOC feature supports only Qt 4 and " - "Qt 5 ", autogenTargetName.c_str()); - } -} - -static void GetUicOpts(cmTarget const* target, const std::string& config, - std::string &optString) -{ - cmGeneratorTarget *gtgt = target->GetMakefile() - ->GetGlobalGenerator() - ->GetGeneratorTarget(target); - std::vector<std::string> opts; - gtgt->GetAutoUicOptions(opts, config); - optString = cmJoin(opts, ";"); -} - -void cmQtAutoGeneratorInitializer::SetupAutoUicTarget(cmTarget const* target, - std::vector<std::string> const& skipUic, - std::map<std::string, std::string> &configUicOptions) -{ - cmMakefile *makefile = target->GetMakefile(); - - std::set<std::string> skipped; - skipped.insert(skipUic.begin(), skipUic.end()); - - makefile->AddDefinition("_skip_uic", - cmOutputConverter::EscapeForCMake(cmJoin(skipUic, ";")).c_str()); - - std::vector<cmSourceFile*> uiFilesWithOptions - = makefile->GetQtUiFilesWithOptions(); - - const char *qtVersion = makefile->GetDefinition("_target_qt_version"); - - std::string _uic_opts; - std::vector<std::string> configs; - const std::string& config = makefile->GetConfigurations(configs); - GetUicOpts(target, config, _uic_opts); - - if (!_uic_opts.empty()) - { - _uic_opts = cmOutputConverter::EscapeForCMake(_uic_opts); - makefile->AddDefinition("_uic_target_options", _uic_opts.c_str()); - } - for (std::vector<std::string>::const_iterator li = configs.begin(); - li != configs.end(); ++li) - { - std::string config_uic_opts; - GetUicOpts(target, *li, config_uic_opts); - if (config_uic_opts != _uic_opts) - { - configUicOptions[*li] = - cmOutputConverter::EscapeForCMake(config_uic_opts); - if(_uic_opts.empty()) - { - _uic_opts = config_uic_opts; - } - } - } - - std::string uiFileFiles; - std::string uiFileOptions; - const char* sep = ""; - - for(std::vector<cmSourceFile*>::const_iterator fileIt = - uiFilesWithOptions.begin(); - fileIt != uiFilesWithOptions.end(); - ++fileIt) - { - cmSourceFile* sf = *fileIt; - std::string absFile = cmsys::SystemTools::GetRealPath( - sf->GetFullPath()); - - if (!skipped.insert(absFile).second) - { - continue; - } - uiFileFiles += sep; - uiFileFiles += absFile; - uiFileOptions += sep; - std::string opts = sf->GetProperty("AUTOUIC_OPTIONS"); - cmSystemTools::ReplaceString(opts, ";", "@list_sep@"); - uiFileOptions += opts; - sep = ";"; - } - - makefile->AddDefinition("_qt_uic_options_files", - cmOutputConverter::EscapeForCMake(uiFileFiles).c_str()); - makefile->AddDefinition("_qt_uic_options_options", - cmOutputConverter::EscapeForCMake(uiFileOptions).c_str()); - - std::string targetName = target->GetName(); - if (strcmp(qtVersion, "5") == 0) - { - cmTarget *qt5Uic = makefile->FindTargetToUse("Qt5::uic"); - if (!qt5Uic) - { - // Project does not use Qt5Widgets, but has AUTOUIC ON anyway - } - else - { - makefile->AddDefinition("_qt_uic_executable", - qt5Uic->ImportedGetLocation("")); - } - } - else if (strcmp(qtVersion, "4") == 0) - { - cmTarget *qt4Uic = makefile->FindTargetToUse("Qt4::uic"); - if (!qt4Uic) - { - cmSystemTools::Error("Qt4::uic target not found ", - targetName.c_str()); - return; - } - makefile->AddDefinition("_qt_uic_executable", - qt4Uic->ImportedGetLocation("")); - } - else - { - cmSystemTools::Error("The CMAKE_AUTOUIC feature supports only Qt 4 and " - "Qt 5 ", targetName.c_str()); - } -} - -void cmQtAutoGeneratorInitializer::MergeRccOptions( - std::vector<std::string> &opts, - const std::vector<std::string> &fileOpts, - bool isQt5) -{ - static const char* valueOptions[] = { - "name", - "root", - "compress", - "threshold" - }; - std::vector<std::string> extraOpts; - for(std::vector<std::string>::const_iterator it = fileOpts.begin(); - it != fileOpts.end(); ++it) - { - std::vector<std::string>::iterator existingIt - = std::find(opts.begin(), opts.end(), *it); - if (existingIt != opts.end()) - { - const char *o = it->c_str(); - if (*o == '-') - { - ++o; - } - if (isQt5 && *o == '-') - { - ++o; - } - if (std::find_if(cmArrayBegin(valueOptions), cmArrayEnd(valueOptions), - cmStrCmp(*it)) != cmArrayEnd(valueOptions)) - { - assert(existingIt + 1 != opts.end()); - *(existingIt + 1) = *(it + 1); - ++it; - } - } - else - { - extraOpts.push_back(*it); - } - } - opts.insert(opts.end(), extraOpts.begin(), extraOpts.end()); -} - -void cmQtAutoGeneratorInitializer::SetupAutoRccTarget(cmTarget const* target) -{ - std::string _rcc_files; - const char* sepRccFiles = ""; - cmMakefile *makefile = target->GetMakefile(); - - std::vector<cmSourceFile*> srcFiles; - cmGeneratorTarget *gtgt = target->GetMakefile() - ->GetGlobalGenerator() - ->GetGeneratorTarget(target); - gtgt->GetConfigCommonSourceFiles(srcFiles); - - std::string qrcInputs; - const char* qrcInputsSep = ""; - - std::string rccFileFiles; - std::string rccFileOptions; - const char *optionSep = ""; - - const char *qtVersion = makefile->GetDefinition("_target_qt_version"); - - std::vector<std::string> rccOptions; - if (const char* opts = target->GetProperty("AUTORCC_OPTIONS")) - { - cmSystemTools::ExpandListArgument(opts, rccOptions); - } - std::string qtMajorVersion = makefile->GetSafeDefinition("QT_VERSION_MAJOR"); - if (qtMajorVersion == "") - { - qtMajorVersion = makefile->GetSafeDefinition("Qt5Core_VERSION_MAJOR"); - } - - for(std::vector<cmSourceFile*>::const_iterator fileIt = srcFiles.begin(); - fileIt != srcFiles.end(); - ++fileIt) - { - cmSourceFile* sf = *fileIt; - std::string ext = sf->GetExtension(); - if (ext == "qrc") - { - std::string absFile = cmsys::SystemTools::GetRealPath( - sf->GetFullPath()); - bool skip = cmSystemTools::IsOn(sf->GetPropertyForUser("SKIP_AUTORCC")); - - if (!skip) - { - _rcc_files += sepRccFiles; - _rcc_files += absFile; - sepRccFiles = ";"; - - if (const char *prop = sf->GetProperty("AUTORCC_OPTIONS")) - { - std::vector<std::string> optsVec; - cmSystemTools::ExpandListArgument(prop, optsVec); - cmQtAutoGeneratorInitializer::MergeRccOptions(rccOptions, optsVec, - strcmp(qtVersion, "5") == 0); - } - - if (!rccOptions.empty()) - { - rccFileFiles += optionSep; - rccFileFiles += absFile; - rccFileOptions += optionSep; - } - const char *listSep = ""; - for(std::vector<std::string>::const_iterator it = rccOptions.begin(); - it != rccOptions.end(); - ++it) - { - rccFileOptions += listSep; - rccFileOptions += *it; - listSep = "@list_sep@"; - } - optionSep = ";"; - - std::vector<std::string> depends; - - std::string entriesList; - if (!cmSystemTools::IsOn(sf->GetPropertyForUser("GENERATED"))) - { - if (qtMajorVersion == "5") - { - entriesList = cmQtAutoGeneratorInitializer::ListQt5RccInputs(sf, - target, - depends); - } - else - { - entriesList = - cmQtAutoGeneratorInitializer::ListQt4RccInputs(sf, depends); - } - if (entriesList.empty()) - { - return; - } - } - qrcInputs += qrcInputsSep; - qrcInputs += entriesList; - qrcInputsSep = ";"; - } - } - } - makefile->AddDefinition("_qt_rcc_inputs_" + target->GetName(), - cmOutputConverter::EscapeForCMake(qrcInputs).c_str()); - - makefile->AddDefinition("_rcc_files", - cmOutputConverter::EscapeForCMake(_rcc_files).c_str()); - - makefile->AddDefinition("_qt_rcc_options_files", - cmOutputConverter::EscapeForCMake(rccFileFiles).c_str()); - makefile->AddDefinition("_qt_rcc_options_options", - cmOutputConverter::EscapeForCMake(rccFileOptions).c_str()); - - makefile->AddDefinition("_qt_rcc_executable", - cmQtAutoGeneratorInitializer::GetRccExecutable(target).c_str()); -} - -std::string cmQtAutoGeneratorInitializer::GetRccExecutable( - cmTarget const* target) -{ - cmGeneratorTarget *gtgt = target->GetMakefile() - ->GetGlobalGenerator() - ->GetGeneratorTarget(target); - cmMakefile *makefile = target->GetMakefile(); - const char *qtVersion = makefile->GetDefinition("_target_qt_version"); - if (!qtVersion) - { - qtVersion = makefile->GetDefinition("Qt5Core_VERSION_MAJOR"); - if (!qtVersion) - { - qtVersion = makefile->GetDefinition("QT_VERSION_MAJOR"); - } - if (const char *targetQtVersion = - gtgt->GetLinkInterfaceDependentStringProperty("QT_MAJOR_VERSION", "")) - { - qtVersion = targetQtVersion; - } - } - - std::string targetName = target->GetName(); - if (strcmp(qtVersion, "5") == 0) - { - cmTarget *qt5Rcc = makefile->FindTargetToUse("Qt5::rcc"); - if (!qt5Rcc) - { - cmSystemTools::Error("Qt5::rcc target not found ", - targetName.c_str()); - return std::string(); - } - return qt5Rcc->ImportedGetLocation(""); - } - else if (strcmp(qtVersion, "4") == 0) - { - cmTarget *qt4Rcc = makefile->FindTargetToUse("Qt4::rcc"); - if (!qt4Rcc) - { - cmSystemTools::Error("Qt4::rcc target not found ", - targetName.c_str()); - return std::string(); - } - return qt4Rcc->ImportedGetLocation(""); - } - - cmSystemTools::Error("The CMAKE_AUTORCC feature supports only Qt 4 and " - "Qt 5 ", targetName.c_str()); - return std::string(); -} diff --git a/Source/cmQtAutoGeneratorInitializer.h b/Source/cmQtAutoGeneratorInitializer.h index c22f172..eaf140d 100644 --- a/Source/cmQtAutoGeneratorInitializer.h +++ b/Source/cmQtAutoGeneratorInitializer.h @@ -21,47 +21,16 @@ #include <map> class cmSourceFile; -class cmTarget; +class cmGeneratorTarget; class cmLocalGenerator; class cmQtAutoGeneratorInitializer { public: - static void InitializeAutogenSources(cmTarget* target); - static void InitializeAutogenTarget(cmLocalGenerator* lg, cmTarget* target); - static void SetupAutoGenerateTarget(cmTarget const* target); - - static std::string GetAutogenTargetName(cmTarget const* target); - static std::string GetAutogenTargetDir(cmTarget const* target); - -private: - static void SetupSourceFiles(cmTarget const* target, - std::vector<std::string>& skipMoc, - std::vector<std::string>& mocSources, - std::vector<std::string>& mocHeaders, - std::vector<std::string>& skipUic); - - static void SetupAutoMocTarget(cmTarget const* target, - const std::string &autogenTargetName, - const std::vector<std::string>& skipMoc, - const std::vector<std::string>& mocHeaders, - std::map<std::string, std::string> &configIncludes, - std::map<std::string, std::string> &configDefines); - static void SetupAutoUicTarget(cmTarget const* target, - const std::vector<std::string>& skipUic, - std::map<std::string, std::string> &configUicOptions); - static void SetupAutoRccTarget(cmTarget const* target); - - static void MergeRccOptions(std::vector<std::string> &opts, - const std::vector<std::string> &fileOpts, bool isQt5); - - static std::string GetRccExecutable(cmTarget const* target); - - static std::string ListQt5RccInputs(cmSourceFile* sf, cmTarget const* target, - std::vector<std::string>& depends); - - static std::string ListQt4RccInputs(cmSourceFile* sf, - std::vector<std::string>& depends); + static void InitializeAutogenSources(cmGeneratorTarget* target); + static void InitializeAutogenTarget(cmLocalGenerator* lg, + cmGeneratorTarget* target); + static void SetupAutoGenerateTarget(cmGeneratorTarget const* target); }; #endif diff --git a/Source/cmQtAutoGenerators.cxx b/Source/cmQtAutoGenerators.cxx index bbeb3dc..b16eccd 100644 --- a/Source/cmQtAutoGenerators.cxx +++ b/Source/cmQtAutoGenerators.cxx @@ -175,12 +175,14 @@ bool cmQtAutoGenerators::Run(const std::string& targetDirectory, cmake cm; cm.SetHomeOutputDirectory(targetDirectory); cm.SetHomeDirectory(targetDirectory); + cm.GetCurrentSnapshot().SetDefaultDefinitions(); cmGlobalGenerator gg(&cm); cmState::Snapshot snapshot = cm.GetCurrentSnapshot(); + snapshot.GetDirectory().SetCurrentBinary(targetDirectory); + snapshot.GetDirectory().SetCurrentSource(targetDirectory); + cmsys::auto_ptr<cmMakefile> mf(new cmMakefile(&gg, snapshot)); - mf->SetCurrentBinaryDirectory(targetDirectory); - mf->SetCurrentSourceDirectory(targetDirectory); gg.SetCurrentMakefile(mf.get()); this->ReadAutogenInfoFile(mf.get(), targetDirectory, config); @@ -526,7 +528,7 @@ bool cmQtAutoGenerators::RunAutogen(cmMakefile* makefile) cmSystemTools::ExpandListArgument(this->Sources, sourceFiles); const std::vector<std::string>& headerExtensions = - makefile->GetHeaderExtensions(); + makefile->GetCMakeInstance()->GetHeaderExtensions(); std::map<std::string, std::vector<std::string> > includedUis; std::map<std::string, std::vector<std::string> > skippedUis; diff --git a/Source/cmSetTargetPropertiesCommand.cxx b/Source/cmSetTargetPropertiesCommand.cxx index 06217bb..b1c13ac 100644 --- a/Source/cmSetTargetPropertiesCommand.cxx +++ b/Source/cmSetTargetPropertiesCommand.cxx @@ -10,7 +10,6 @@ See the License for more information. ============================================================================*/ #include "cmSetTargetPropertiesCommand.h" -#include "cmLocalGenerator.h" #include "cmGlobalGenerator.h" // cmSetTargetPropertiesCommand diff --git a/Source/cmSourceFile.cxx b/Source/cmSourceFile.cxx index 86f0a7a..a9ac549 100644 --- a/Source/cmSourceFile.cxx +++ b/Source/cmSourceFile.cxx @@ -12,7 +12,6 @@ #include "cmSourceFile.h" #include "cmGlobalGenerator.h" -#include "cmLocalGenerator.h" #include "cmMakefile.h" #include "cmSystemTools.h" #include "cmake.h" @@ -168,8 +167,10 @@ bool cmSourceFile::FindFullPath(std::string* error) { tryDirs[0] = ""; } - const std::vector<std::string>& srcExts = mf->GetSourceExtensions(); - const std::vector<std::string>& hdrExts = mf->GetHeaderExtensions(); + const std::vector<std::string>& srcExts = + mf->GetCMakeInstance()->GetSourceExtensions(); + std::vector<std::string> hdrExts = + mf->GetCMakeInstance()->GetHeaderExtensions(); for(const char* const* di = tryDirs; *di; ++di) { std::string tryPath = this->Location.GetDirectory(); diff --git a/Source/cmSourceFileLocation.cxx b/Source/cmSourceFileLocation.cxx index 4a87cc2..00d5d6a 100644 --- a/Source/cmSourceFileLocation.cxx +++ b/Source/cmSourceFileLocation.cxx @@ -12,7 +12,6 @@ #include "cmSourceFileLocation.h" #include "cmMakefile.h" -#include "cmLocalGenerator.h" #include "cmGlobalGenerator.h" #include "cmSystemTools.h" #include "cmAlgorithms.h" @@ -122,8 +121,10 @@ void cmSourceFileLocation::UpdateExtension(const std::string& name) // The global generator checks extensions of enabled languages. cmGlobalGenerator* gg = this->Makefile->GetGlobalGenerator(); cmMakefile const* mf = this->Makefile; - const std::vector<std::string>& srcExts = mf->GetSourceExtensions(); - const std::vector<std::string>& hdrExts = mf->GetHeaderExtensions(); + const std::vector<std::string>& srcExts = + mf->GetCMakeInstance()->GetSourceExtensions(); + const std::vector<std::string>& hdrExts = + mf->GetCMakeInstance()->GetHeaderExtensions(); if(!gg->GetLanguageFromExtension(ext.c_str()).empty() || std::find(srcExts.begin(), srcExts.end(), ext) != srcExts.end() || std::find(hdrExts.begin(), hdrExts.end(), ext) != hdrExts.end()) @@ -194,12 +195,14 @@ cmSourceFileLocation // disk. One of these must match if loc refers to this source file. std::string const& ext = this->Name.substr(loc.Name.size()+1); cmMakefile const* mf = this->Makefile; - const std::vector<std::string>& srcExts = mf->GetSourceExtensions(); + const std::vector<std::string>& srcExts = + mf->GetCMakeInstance()->GetSourceExtensions(); if(std::find(srcExts.begin(), srcExts.end(), ext) != srcExts.end()) { return true; } - const std::vector<std::string>& hdrExts = mf->GetHeaderExtensions(); + std::vector<std::string> hdrExts = + mf->GetCMakeInstance()->GetHeaderExtensions(); if(std::find(hdrExts.begin(), hdrExts.end(), ext) != hdrExts.end()) { return true; diff --git a/Source/cmStandardIncludes.h b/Source/cmStandardIncludes.h index 468a589..dd8fa9c 100644 --- a/Source/cmStandardIncludes.h +++ b/Source/cmStandardIncludes.h @@ -123,4 +123,10 @@ static thisClass* SafeDownCast(cmObject *c) \ } \ class cmTypeMacro_UseTrailingSemicolon +enum cmTargetLinkLibraryType { + GENERAL_LibraryType, + DEBUG_LibraryType, + OPTIMIZED_LibraryType +}; + #endif diff --git a/Source/cmState.cxx b/Source/cmState.cxx index c1ead6c..b8e604b 100644 --- a/Source/cmState.cxx +++ b/Source/cmState.cxx @@ -12,6 +12,7 @@ #include "cmState.h" #include "cmake.h" +#include "cmVersion.h" #include "cmCacheManager.h" #include "cmCommand.h" #include "cmAlgorithms.h" @@ -83,9 +84,8 @@ struct cmState::BuildsystemDirectoryStateType std::vector<cmState::Snapshot> Children; }; -cmState::cmState(cmake* cm) - : CMakeInstance(cm), - IsInTryCompile(false), +cmState::cmState() + : IsInTryCompile(false), WindowsShell(false), WindowsVSIDE(false), WatcomWMake(false), @@ -93,13 +93,42 @@ cmState::cmState(cmake* cm) NMake(false), MSYSShell(false) { + this->CacheManager = new cmCacheManager; } cmState::~cmState() { + delete this->CacheManager; cmDeleteAll(this->Commands); } +const char* cmState::GetTargetTypeName(cmState::TargetType targetType) +{ + switch( targetType ) + { + case cmState::STATIC_LIBRARY: + return "STATIC_LIBRARY"; + case cmState::MODULE_LIBRARY: + return "MODULE_LIBRARY"; + case cmState::SHARED_LIBRARY: + return "SHARED_LIBRARY"; + case cmState::OBJECT_LIBRARY: + return "OBJECT_LIBRARY"; + case cmState::EXECUTABLE: + return "EXECUTABLE"; + case cmState::UTILITY: + return "UTILITY"; + case cmState::GLOBAL_TARGET: + return "GLOBAL_TARGET"; + case cmState::INTERFACE_LIBRARY: + return "INTERFACE_LIBRARY"; + case cmState::UNKNOWN_LIBRARY: + return "UNKNOWN_LIBRARY"; + } + assert(0 && "Unexpected target type"); + return 0; +} + const char* cmCacheEntryTypes[] = { "BOOL", "PATH", @@ -148,12 +177,30 @@ bool cmState::IsCacheEntryType(std::string const& key) return false; } +bool cmState::LoadCache(const std::string& path, bool internal, + std::set<std::string>& excludes, + std::set<std::string>& includes) +{ + return this->CacheManager->LoadCache(path, internal, + excludes, includes); +} + +bool cmState::SaveCache(const std::string& path) +{ + return this->CacheManager->SaveCache(path); +} + +bool cmState::DeleteCache(const std::string& path) +{ + return this->CacheManager->DeleteCache(path); +} + std::vector<std::string> cmState::GetCacheEntryKeys() const { std::vector<std::string> definitions; - definitions.reserve(this->CMakeInstance->GetCacheManager()->GetSize()); + definitions.reserve(this->CacheManager->GetSize()); cmCacheManager::CacheIterator cit = - this->CMakeInstance->GetCacheManager()->GetCacheIterator(); + this->CacheManager->GetCacheIterator(); for ( cit.Begin(); !cit.IsAtEnd(); cit.Next() ) { definitions.push_back(cit.GetName()); @@ -163,7 +210,7 @@ std::vector<std::string> cmState::GetCacheEntryKeys() const const char* cmState::GetCacheEntryValue(std::string const& key) const { - cmCacheManager::CacheEntry* e = this->CMakeInstance->GetCacheManager() + cmCacheManager::CacheEntry* e = this->CacheManager ->GetCacheEntry(key); if (!e) { @@ -175,21 +222,21 @@ const char* cmState::GetCacheEntryValue(std::string const& key) const const char* cmState::GetInitializedCacheValue(std::string const& key) const { - return this->CMakeInstance->GetCacheManager()->GetInitializedCacheValue(key); + return this->CacheManager->GetInitializedCacheValue(key); } cmState::CacheEntryType cmState::GetCacheEntryType(std::string const& key) const { cmCacheManager::CacheIterator it = - this->CMakeInstance->GetCacheManager()->GetCacheIterator(key.c_str()); + this->CacheManager->GetCacheIterator(key.c_str()); return it.GetType(); } void cmState::SetCacheEntryValue(std::string const& key, std::string const& value) { - this->CMakeInstance->GetCacheManager()->SetCacheEntryValue(key, value); + this->CacheManager->SetCacheEntryValue(key, value); } void cmState::SetCacheEntryProperty(std::string const& key, @@ -197,7 +244,7 @@ void cmState::SetCacheEntryProperty(std::string const& key, std::string const& value) { cmCacheManager::CacheIterator it = - this->CMakeInstance->GetCacheManager()->GetCacheIterator(key.c_str()); + this->CacheManager->GetCacheIterator(key.c_str()); it.SetProperty(propertyName, value.c_str()); } @@ -206,14 +253,14 @@ void cmState::SetCacheEntryBoolProperty(std::string const& key, bool value) { cmCacheManager::CacheIterator it = - this->CMakeInstance->GetCacheManager()->GetCacheIterator(key.c_str()); + this->CacheManager->GetCacheIterator(key.c_str()); it.SetProperty(propertyName, value); } const char* cmState::GetCacheEntryProperty(std::string const& key, std::string const& propertyName) { - cmCacheManager::CacheIterator it = this->CMakeInstance->GetCacheManager() + cmCacheManager::CacheIterator it = this->CacheManager ->GetCacheIterator(key.c_str()); if (!it.PropertyExists(propertyName)) { @@ -225,7 +272,7 @@ const char* cmState::GetCacheEntryProperty(std::string const& key, bool cmState::GetCacheEntryPropertyAsBool(std::string const& key, std::string const& propertyName) { - return this->CMakeInstance->GetCacheManager() + return this->CacheManager ->GetCacheIterator(key.c_str()).GetPropertyAsBool(propertyName); } @@ -233,13 +280,13 @@ void cmState::AddCacheEntry(const std::string& key, const char* value, const char* helpString, cmState::CacheEntryType type) { - this->CMakeInstance->GetCacheManager()->AddCacheEntry(key, value, + this->CacheManager->AddCacheEntry(key, value, helpString, type); } void cmState::RemoveCacheEntry(std::string const& key) { - this->CMakeInstance->GetCacheManager()->RemoveCacheEntry(key); + this->CacheManager->RemoveCacheEntry(key); } void cmState::AppendCacheEntryProperty(const std::string& key, @@ -247,7 +294,7 @@ void cmState::AppendCacheEntryProperty(const std::string& key, const std::string& value, bool asString) { - this->CMakeInstance->GetCacheManager() + this->CacheManager ->GetCacheIterator(key.c_str()).AppendProperty(property, value.c_str(), asString); @@ -256,7 +303,7 @@ void cmState::AppendCacheEntryProperty(const std::string& key, void cmState::RemoveCacheEntryProperty(std::string const& key, std::string const& propertyName) { - this->CMakeInstance->GetCacheManager() + this->CacheManager ->GetCacheIterator(key.c_str()).SetProperty(propertyName, (void*)0); } @@ -288,11 +335,21 @@ cmState::Snapshot cmState::Reset() pos->PolicyScope = this->PolicyStack.Root(); assert(pos->Policies.IsValid()); assert(pos->PolicyRoot.IsValid()); + + { + std::string srcDir = + cmDefinitions::Get("CMAKE_SOURCE_DIR", pos->Vars, pos->Root); + std::string binDir = + cmDefinitions::Get("CMAKE_BINARY_DIR", pos->Vars, pos->Root); this->VarTree.Clear(); pos->Vars = this->VarTree.Push(this->VarTree.Root()); pos->Parent = this->VarTree.Root(); pos->Root = this->VarTree.Root(); + pos->Vars->Set("CMAKE_SOURCE_DIR", srcDir.c_str()); + pos->Vars->Set("CMAKE_BINARY_DIR", binDir.c_str()); + } + this->DefineProperty ("RULE_LAUNCH_COMPILE", cmProperty::DIRECTORY, "", "", true); @@ -660,6 +717,16 @@ bool cmState::UseMSYSShell() const return this->MSYSShell; } +unsigned int cmState::GetCacheMajorVersion() const +{ + return this->CacheManager->GetCacheMajorVersion(); +} + +unsigned int cmState::GetCacheMinorVersion() const +{ + return this->CacheManager->GetCacheMinorVersion(); +} + const char* cmState::GetBinaryDirectory() const { return this->BinaryDirectory.c_str(); @@ -808,8 +875,12 @@ cmState::CreateBuildsystemDirectorySnapshot(Snapshot originSnapshot, pos->Parent = origin; pos->Root = origin; pos->Vars = this->VarTree.Push(origin); + cmState::Snapshot snapshot = cmState::Snapshot(this, pos); originSnapshot.Position->BuildSystemDirectory->Children.push_back(snapshot); + snapshot.SetDefaultDefinitions(); + snapshot.InitializeFromParent(); + snapshot.SetDirectoryDefinitions(); return snapshot; } @@ -1003,6 +1074,8 @@ void cmState::Directory::SetCurrentSource(std::string const& dir) loc, this->DirectoryState->CurrentSourceDirectoryComponents); this->ComputeRelativePathTopSource(); + + this->Snapshot_.SetDefinition("CMAKE_CURRENT_SOURCE_DIR", loc.c_str()); } const char* cmState::Directory::GetCurrentBinary() const @@ -1021,6 +1094,8 @@ void cmState::Directory::SetCurrentBinary(std::string const& dir) loc, this->DirectoryState->CurrentBinaryDirectoryComponents); this->ComputeRelativePathTopBinary(); + + this->Snapshot_.SetDefinition("CMAKE_CURRENT_BINARY_DIR", loc.c_str()); } void cmState::Snapshot::Keep() @@ -1319,6 +1394,70 @@ void InitializeContentFromParent(T& parentContent, contentEndPosition = thisContent.size(); } +void cmState::Snapshot::SetDefaultDefinitions() +{ + /* Up to CMake 2.4 here only WIN32, UNIX and APPLE were set. + With CMake must separate between target and host platform. In most cases + the tests for WIN32, UNIX and APPLE will be for the target system, so an + additional set of variables for the host system is required -> + CMAKE_HOST_WIN32, CMAKE_HOST_UNIX, CMAKE_HOST_APPLE. + WIN32, UNIX and APPLE are now set in the platform files in + Modules/Platforms/. + To keep cmake scripts (-P) and custom language and compiler modules + working, these variables are still also set here in this place, but they + will be reset in CMakeSystemSpecificInformation.cmake before the platform + files are executed. */ + #if defined(_WIN32) + this->SetDefinition("WIN32", "1"); + this->SetDefinition("CMAKE_HOST_WIN32", "1"); + #else + this->SetDefinition("UNIX", "1"); + this->SetDefinition("CMAKE_HOST_UNIX", "1"); + #endif + #if defined(__CYGWIN__) + if(cmSystemTools::IsOn(cmSystemTools::GetEnv("CMAKE_LEGACY_CYGWIN_WIN32"))) + { + this->SetDefinition("WIN32", "1"); + this->SetDefinition("CMAKE_HOST_WIN32", "1"); + } + #endif + #if defined(__APPLE__) + this->SetDefinition("APPLE", "1"); + this->SetDefinition("CMAKE_HOST_APPLE", "1"); + #endif + + char temp[1024]; + sprintf(temp, "%d", cmVersion::GetMinorVersion()); + this->SetDefinition("CMAKE_MINOR_VERSION", temp); + sprintf(temp, "%d", cmVersion::GetMajorVersion()); + this->SetDefinition("CMAKE_MAJOR_VERSION", temp); + sprintf(temp, "%d", cmVersion::GetPatchVersion()); + this->SetDefinition("CMAKE_PATCH_VERSION", temp); + sprintf(temp, "%d", cmVersion::GetTweakVersion()); + this->SetDefinition("CMAKE_TWEAK_VERSION", temp); + this->SetDefinition("CMAKE_VERSION", + cmVersion::GetCMakeVersion()); + + this->SetDefinition("CMAKE_FILES_DIRECTORY", + cmake::GetCMakeFilesDirectory()); + + // Setup the default include file regular expression (match everything). + this->Position->BuildSystemDirectory + ->Properties.SetProperty("INCLUDE_REGULAR_EXPRESSION", "^.*$"); +} + +void cmState::Snapshot::SetDirectoryDefinitions() +{ + this->SetDefinition("CMAKE_SOURCE_DIR", + this->State->GetSourceDirectory()); + this->SetDefinition("CMAKE_CURRENT_SOURCE_DIR", + this->State->GetSourceDirectory()); + this->SetDefinition("CMAKE_BINARY_DIR", + this->State->GetBinaryDirectory()); + this->SetDefinition("CMAKE_CURRENT_BINARY_DIR", + this->State->GetBinaryDirectory()); +} + void cmState::Snapshot::InitializeFromParent() { PositionType parent = this->Position->DirectoryParent; @@ -1367,6 +1506,20 @@ std::string cmState::Snapshot::GetProjectName() const return this->Position->BuildSystemDirectory->ProjectName; } +void cmState::Snapshot::InitializeFromParent_ForSubdirsCommand() +{ + std::string currentSrcDir = this->GetDefinition("CMAKE_CURRENT_SOURCE_DIR"); + std::string currentBinDir = this->GetDefinition("CMAKE_CURRENT_BINARY_DIR"); + this->InitializeFromParent(); + this->SetDefinition("CMAKE_SOURCE_DIR", + this->State->GetSourceDirectory()); + this->SetDefinition("CMAKE_BINARY_DIR", + this->State->GetBinaryDirectory()); + + this->SetDefinition("CMAKE_CURRENT_SOURCE_DIR", currentSrcDir.c_str()); + this->SetDefinition("CMAKE_CURRENT_BINARY_DIR", currentBinDir.c_str()); +} + cmState::Directory::Directory( cmLinkedTree<BuildsystemDirectoryStateType>::iterator iter, const cmState::Snapshot& snapshot) @@ -1771,3 +1924,87 @@ bool operator!=(const cmState::Snapshot& lhs, const cmState::Snapshot& rhs) { return lhs.Position != rhs.Position; } + +static bool ParseEntryWithoutType(const std::string& entry, + std::string& var, + std::string& value) +{ + // input line is: key=value + static cmsys::RegularExpression reg( + "^([^=]*)=(.*[^\r\t ]|[\r\t ]*)[\r\t ]*$"); + // input line is: "key"=value + static cmsys::RegularExpression regQuoted( + "^\"([^\"]*)\"=(.*[^\r\t ]|[\r\t ]*)[\r\t ]*$"); + bool flag = false; + if(regQuoted.find(entry)) + { + var = regQuoted.match(1); + value = regQuoted.match(2); + flag = true; + } + else if (reg.find(entry)) + { + var = reg.match(1); + value = reg.match(2); + flag = true; + } + + // if value is enclosed in single quotes ('foo') then remove them + // it is used to enclose trailing space or tab + if (flag && + value.size() >= 2 && + value[0] == '\'' && + value[value.size() - 1] == '\'') + { + value = value.substr(1, + value.size() - 2); + } + + return flag; +} + +bool cmState::ParseCacheEntry(const std::string& entry, + std::string& var, + std::string& value, + CacheEntryType& type) +{ + // input line is: key:type=value + static cmsys::RegularExpression reg( + "^([^=:]*):([^=]*)=(.*[^\r\t ]|[\r\t ]*)[\r\t ]*$"); + // input line is: "key":type=value + static cmsys::RegularExpression regQuoted( + "^\"([^\"]*)\":([^=]*)=(.*[^\r\t ]|[\r\t ]*)[\r\t ]*$"); + bool flag = false; + if(regQuoted.find(entry)) + { + var = regQuoted.match(1); + type = cmState::StringToCacheEntryType(regQuoted.match(2).c_str()); + value = regQuoted.match(3); + flag = true; + } + else if (reg.find(entry)) + { + var = reg.match(1); + type = cmState::StringToCacheEntryType(reg.match(2).c_str()); + value = reg.match(3); + flag = true; + } + + // if value is enclosed in single quotes ('foo') then remove them + // it is used to enclose trailing space or tab + if (flag && + value.size() >= 2 && + value[0] == '\'' && + value[value.size() - 1] == '\'') + { + value = value.substr(1, + value.size() - 2); + } + + if (!flag) + { + return ParseEntryWithoutType(entry, var, value); + } + + return flag; +} diff --git a/Source/cmState.h b/Source/cmState.h index a66603f..6717481 100644 --- a/Source/cmState.h +++ b/Source/cmState.h @@ -23,6 +23,7 @@ class cmake; class cmCommand; class cmDefinitions; class cmListFileBacktrace; +class cmCacheManager; class cmState { @@ -32,7 +33,7 @@ class cmState typedef cmLinkedTree<SnapshotDataType>::iterator PositionType; friend class Snapshot; public: - cmState(cmake* cm); + cmState(); ~cmState(); enum SnapshotType @@ -76,8 +77,6 @@ public: Snapshot GetCallStackParent() const; SnapshotType GetType() const; - void InitializeFromParent(); - void SetPolicy(cmPolicies::PolicyID id, cmPolicies::PolicyStatus status); cmPolicies::PolicyStatus GetPolicy(cmPolicies::PolicyID id) const; bool HasDefinedPolicyCMP0011(); @@ -92,12 +91,17 @@ public: void SetProjectName(std::string const& name); std::string GetProjectName() const; + void InitializeFromParent_ForSubdirsCommand(); + struct StrictWeakOrder { bool operator()(const cmState::Snapshot& lhs, const cmState::Snapshot& rhs) const; }; + void SetDirectoryDefinitions(); + void SetDefaultDefinitions(); + private: friend bool operator==(const cmState::Snapshot& lhs, const cmState::Snapshot& rhs); @@ -106,6 +110,9 @@ public: friend class cmState; friend class Directory; friend struct StrictWeakOrder; + + void InitializeFromParent(); + cmState* State; cmState::PositionType Position; }; @@ -175,6 +182,14 @@ public: friend class Snapshot; }; + enum TargetType { EXECUTABLE, STATIC_LIBRARY, + SHARED_LIBRARY, MODULE_LIBRARY, + OBJECT_LIBRARY, UTILITY, GLOBAL_TARGET, + INTERFACE_LIBRARY, + UNKNOWN_LIBRARY}; + + static const char* GetTargetTypeName(cmState::TargetType targetType); + Snapshot CreateBaseSnapshot(); Snapshot CreateBuildsystemDirectorySnapshot(Snapshot originSnapshot, @@ -208,6 +223,14 @@ public: static const char* CacheEntryTypeToString(CacheEntryType); static bool IsCacheEntryType(std::string const& key); + bool LoadCache(const std::string& path, bool internal, + std::set<std::string>& excludes, + std::set<std::string>& includes); + + bool SaveCache(const std::string& path) ; + + bool DeleteCache(const std::string& path); + std::vector<std::string> GetCacheEntryKeys() const; const char* GetCacheEntryValue(std::string const& key) const; const char* GetInitializedCacheValue(std::string const& key) const; @@ -215,8 +238,6 @@ public: void SetCacheEntryValue(std::string const& key, std::string const& value); void SetCacheValue(std::string const& key, std::string const& value); - void AddCacheEntry(const std::string& key, const char* value, - const char* helpString, CacheEntryType type); void RemoveCacheEntry(std::string const& key); void SetCacheEntryProperty(std::string const& key, @@ -236,6 +257,12 @@ public: void RemoveCacheEntryProperty(std::string const& key, std::string const& propertyName); + ///! Break up a line like VAR:type="value" into var, type and value + static bool ParseCacheEntry(const std::string& entry, + std::string& var, + std::string& value, + CacheEntryType& type); + Snapshot Reset(); // Define a property void DefineProperty(const std::string& name, cmProperty::ScopeType scope, @@ -296,12 +323,19 @@ public: void SetMSYSShell(bool mSYSShell); bool UseMSYSShell() const; + unsigned int GetCacheMajorVersion() const; + unsigned int GetCacheMinorVersion() const; + private: + friend class cmake; + void AddCacheEntry(const std::string& key, const char* value, + const char* helpString, CacheEntryType type); + std::map<cmProperty::ScopeType, cmPropertyDefinitionMap> PropertyDefinitions; std::vector<std::string> EnabledLanguages; std::map<std::string, cmCommand*> Commands; cmPropertyMap GlobalProperties; - cmake* CMakeInstance; + cmCacheManager* CacheManager; cmLinkedTree<BuildsystemDirectoryStateType> BuildsystemDirectory; diff --git a/Source/cmSystemTools.cxx b/Source/cmSystemTools.cxx index 2c5aa8a..b2827dc 100644 --- a/Source/cmSystemTools.cxx +++ b/Source/cmSystemTools.cxx @@ -29,6 +29,9 @@ # include "cmArchiveWrite.h" # include "cmLocale.h" # include <cm_libarchive.h> +# ifndef __LA_INT64_T +# define __LA_INT64_T la_int64_t +# endif #endif #include <cmsys/FStream.hxx> #include <cmsys/Terminal.h> diff --git a/Source/cmTarget.cxx b/Source/cmTarget.cxx index bb44956..9ea1a34 100644 --- a/Source/cmTarget.cxx +++ b/Source/cmTarget.cxx @@ -33,91 +33,10 @@ #define UNORDERED_SET std::set #endif -const char* cmTarget::GetTargetTypeName(TargetType targetType) -{ - switch( targetType ) - { - case cmTarget::STATIC_LIBRARY: - return "STATIC_LIBRARY"; - case cmTarget::MODULE_LIBRARY: - return "MODULE_LIBRARY"; - case cmTarget::SHARED_LIBRARY: - return "SHARED_LIBRARY"; - case cmTarget::OBJECT_LIBRARY: - return "OBJECT_LIBRARY"; - case cmTarget::EXECUTABLE: - return "EXECUTABLE"; - case cmTarget::UTILITY: - return "UTILITY"; - case cmTarget::GLOBAL_TARGET: - return "GLOBAL_TARGET"; - case cmTarget::INTERFACE_LIBRARY: - return "INTERFACE_LIBRARY"; - case cmTarget::UNKNOWN_LIBRARY: - return "UNKNOWN_LIBRARY"; - } - assert(0 && "Unexpected target type"); - return 0; -} - -//---------------------------------------------------------------------------- -struct cmTarget::OutputInfo -{ - std::string OutDir; - std::string ImpDir; - std::string PdbDir; - bool empty() const - { return OutDir.empty() && ImpDir.empty() && PdbDir.empty(); } -}; - //---------------------------------------------------------------------------- class cmTargetInternals { public: - cmTargetInternals() - : Backtrace() - { - this->UtilityItemsDone = false; - } - cmTargetInternals(cmTargetInternals const&) - : Backtrace() - { - this->UtilityItemsDone = false; - } - ~cmTargetInternals(); - - // The backtrace when the target was created. - cmListFileBacktrace Backtrace; - - typedef std::map<std::string, cmTarget::OutputInfo> OutputInfoMapType; - OutputInfoMapType OutputInfoMap; - - typedef std::map<std::string, cmTarget::ImportInfo> ImportInfoMapType; - ImportInfoMapType ImportInfoMap; - - struct HeadToLinkImplementationMap: - public std::map<cmTarget const*, cmOptionalLinkImplementation> {}; - typedef std::map<std::string, - HeadToLinkImplementationMap> LinkImplMapType; - LinkImplMapType LinkImplMap; - - typedef std::map<std::string, std::vector<cmSourceFile*> > - SourceFilesMapType; - SourceFilesMapType SourceFilesMap; - - std::set<cmLinkItem> UtilityItems; - bool UtilityItemsDone; - - class TargetPropertyEntry { - static cmLinkImplItem NoLinkImplItem; - public: - TargetPropertyEntry(cmsys::auto_ptr<cmCompiledGeneratorExpression> cge, - cmLinkImplItem const& item = NoLinkImplItem) - : ge(cge), LinkImplItem(item) - {} - const cmsys::auto_ptr<cmCompiledGeneratorExpression> ge; - cmLinkImplItem const& LinkImplItem; - }; std::vector<std::string> IncludeDirectoriesEntries; std::vector<cmListFileBacktrace> IncludeDirectoriesBacktraces; std::vector<std::string> CompileOptionsEntries; @@ -126,21 +45,12 @@ public: std::vector<cmListFileBacktrace> CompileFeaturesBacktraces; std::vector<std::string> CompileDefinitionsEntries; std::vector<cmListFileBacktrace> CompileDefinitionsBacktraces; - std::vector<TargetPropertyEntry*> SourceEntries; - std::vector<cmValueWithOrigin> LinkImplementationPropertyEntries; - - void AddInterfaceEntries( - cmTarget const* thisTarget, std::string const& config, - std::string const& prop, std::vector<TargetPropertyEntry*>& entries); + std::vector<std::string> SourceEntries; + std::vector<cmListFileBacktrace> SourceBacktraces; + std::vector<std::string> LinkImplementationPropertyEntries; + std::vector<cmListFileBacktrace> LinkImplementationPropertyBacktraces; }; -cmLinkImplItem cmTargetInternals::TargetPropertyEntry::NoLinkImplItem; - -//---------------------------------------------------------------------------- -cmTargetInternals::~cmTargetInternals() -{ -} - //---------------------------------------------------------------------------- cmTarget::cmTarget() { @@ -151,20 +61,18 @@ cmTarget::cmTarget() this->HaveInstallRule = false; this->DLLPlatform = false; this->IsAndroid = false; - this->IsApple = false; this->IsImportedTarget = false; + this->ImportedGloballyVisible = false; this->BuildInterfaceIncludesAppended = false; - this->DebugSourcesDone = false; - this->LinkImplementationLanguageIsContextDependent = true; } -void cmTarget::SetType(TargetType type, const std::string& name) +void cmTarget::SetType(cmState::TargetType type, const std::string& name) { this->Name = name; // only add dependency information for library targets this->TargetTypeValue = type; - if(this->TargetTypeValue >= STATIC_LIBRARY - && this->TargetTypeValue <= MODULE_LIBRARY) + if(this->TargetTypeValue >= cmState::STATIC_LIBRARY + && this->TargetTypeValue <= cmState::MODULE_LIBRARY) { this->RecordDependencies = true; } @@ -190,11 +98,9 @@ void cmTarget::SetMakefile(cmMakefile* mf) strcmp(this->Makefile->GetSafeDefinition("CMAKE_SYSTEM_NAME"), "Android") == 0; - // Check whether we are targeting an Apple platform. - this->IsApple = this->Makefile->IsOn("APPLE"); - // Setup default property values. - if (this->GetType() != INTERFACE_LIBRARY && this->GetType() != UTILITY) + if (this->GetType() != cmState::INTERFACE_LIBRARY + && this->GetType() != cmState::UTILITY) { this->SetPropertyDefault("ANDROID_API", 0); this->SetPropertyDefault("ANDROID_API_MIN", 0); @@ -257,7 +163,7 @@ void cmTarget::SetMakefile(cmMakefile* mf) mf->GetConfigurations(configNames); // Setup per-configuration property default values. - if (this->GetType() != UTILITY) + if (this->GetType() != cmState::UTILITY) { const char* configProps[] = { "ARCHIVE_OUTPUT_DIRECTORY_", @@ -273,7 +179,7 @@ void cmTarget::SetMakefile(cmMakefile* mf) std::string configUpper = cmSystemTools::UpperCase(*ci); for(const char** p = configProps; *p; ++p) { - if (this->TargetTypeValue == INTERFACE_LIBRARY + if (this->TargetTypeValue == cmState::INTERFACE_LIBRARY && strcmp(*p, "MAP_IMPORTED_CONFIG_") != 0) { continue; @@ -288,8 +194,8 @@ void cmTarget::SetMakefile(cmMakefile* mf) // compatibility with previous CMake versions in which executables // did not support this variable. Projects may still specify the // property directly. - if(this->TargetTypeValue != cmTarget::EXECUTABLE - && this->TargetTypeValue != cmTarget::INTERFACE_LIBRARY) + if(this->TargetTypeValue != cmState::EXECUTABLE + && this->TargetTypeValue != cmState::INTERFACE_LIBRARY) { std::string property = cmSystemTools::UpperCase(*ci); property += "_POSTFIX"; @@ -299,7 +205,7 @@ void cmTarget::SetMakefile(cmMakefile* mf) } // Save the backtrace of target construction. - this->Internal->Backtrace = this->Makefile->GetBacktrace(); + this->Backtrace = this->Makefile->GetBacktrace(); if (!this->IsImported()) { @@ -336,30 +242,32 @@ void cmTarget::SetMakefile(cmMakefile* mf) parentOptionsBts.begin(), parentOptionsBts.end()); } - if (this->GetType() != INTERFACE_LIBRARY && this->GetType() != UTILITY) + if (this->GetType() != cmState::INTERFACE_LIBRARY + && this->GetType() != cmState::UTILITY) { this->SetPropertyDefault("C_VISIBILITY_PRESET", 0); this->SetPropertyDefault("CXX_VISIBILITY_PRESET", 0); this->SetPropertyDefault("VISIBILITY_INLINES_HIDDEN", 0); } - if(this->TargetTypeValue == cmTarget::EXECUTABLE) + if(this->TargetTypeValue == cmState::EXECUTABLE) { this->SetPropertyDefault("ANDROID_GUI", 0); this->SetPropertyDefault("CROSSCOMPILING_EMULATOR", 0); this->SetPropertyDefault("ENABLE_EXPORTS", 0); } - if(this->TargetTypeValue == cmTarget::SHARED_LIBRARY - || this->TargetTypeValue == cmTarget::MODULE_LIBRARY) + if(this->TargetTypeValue == cmState::SHARED_LIBRARY + || this->TargetTypeValue == cmState::MODULE_LIBRARY) { this->SetProperty("POSITION_INDEPENDENT_CODE", "True"); } - if(this->TargetTypeValue == cmTarget::SHARED_LIBRARY) + if(this->TargetTypeValue == cmState::SHARED_LIBRARY) { this->SetPropertyDefault("WINDOWS_EXPORT_ALL_SYMBOLS", 0); } - if (this->GetType() != INTERFACE_LIBRARY && this->GetType() != UTILITY) + if (this->GetType() != cmState::INTERFACE_LIBRARY + && this->GetType() != cmState::UTILITY) { this->SetPropertyDefault("POSITION_INDEPENDENT_CODE", 0); } @@ -367,42 +275,29 @@ void cmTarget::SetMakefile(cmMakefile* mf) // Record current policies for later use. this->Makefile->RecordPolicies(this->PolicyMap); - if (this->TargetTypeValue == INTERFACE_LIBRARY) + if (this->TargetTypeValue == cmState::INTERFACE_LIBRARY) { // This policy is checked in a few conditions. The properties relevant - // to the policy are always ignored for INTERFACE_LIBRARY targets, + // to the policy are always ignored for cmState::INTERFACE_LIBRARY targets, // so ensure that the conditions don't lead to nonsense. this->PolicyMap.Set(cmPolicies::CMP0022, cmPolicies::NEW); } - if (this->GetType() != INTERFACE_LIBRARY && this->GetType() != UTILITY) + if (this->GetType() != cmState::INTERFACE_LIBRARY + && this->GetType() != cmState::UTILITY) { this->SetPropertyDefault("JOB_POOL_COMPILE", 0); this->SetPropertyDefault("JOB_POOL_LINK", 0); } } -void CreatePropertyGeneratorExpressions( - std::vector<std::string> const& entries, - std::vector<cmListFileBacktrace> const& backtraces, - std::vector<cmTargetInternals::TargetPropertyEntry*>& items) -{ - std::vector<cmListFileBacktrace>::const_iterator btIt = backtraces.begin(); - for (std::vector<std::string>::const_iterator it = entries.begin(); - it != entries.end(); ++it, ++btIt) - { - cmGeneratorExpression ge(*btIt); - cmsys::auto_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(*it); - items.push_back(new cmTargetInternals::TargetPropertyEntry(cge)); - } -} - //---------------------------------------------------------------------------- void cmTarget::AddUtility(const std::string& u, cmMakefile *makefile) { if(this->Utilities.insert(u).second && makefile) { - UtilityBacktraces.insert(std::make_pair(u, makefile->GetBacktrace())); + this->UtilityBacktraces.insert( + std::make_pair(u, makefile->GetBacktrace())); } } @@ -418,98 +313,30 @@ cmListFileBacktrace const* cmTarget::GetUtilityBacktrace( } //---------------------------------------------------------------------------- -std::set<cmLinkItem> const& cmTarget::GetUtilityItems() const -{ - if(!this->Internal->UtilityItemsDone) - { - this->Internal->UtilityItemsDone = true; - for(std::set<std::string>::const_iterator i = this->Utilities.begin(); - i != this->Utilities.end(); ++i) - { - this->Internal->UtilityItems.insert( - cmLinkItem(*i, this->Makefile->FindTargetToUse(*i))); - } - } - return this->Internal->UtilityItems; -} - -//---------------------------------------------------------------------------- -void cmTarget::FinishConfigure() -{ - // Erase any cached link information that might have been comptued - // on-demand during the configuration. This ensures that build - // system generation uses up-to-date information even if other cache - // invalidation code in this source file is buggy. - this->ClearLinkMaps(); - -#if defined(_WIN32) && !defined(__CYGWIN__) - // Do old-style link dependency analysis only for CM_USE_OLD_VS6. - if(this->Makefile->GetGlobalGenerator()->IsForVS6()) - { - this->AnalyzeLibDependenciesForVS6(*this->Makefile); - } -#endif -} - -//---------------------------------------------------------------------------- -void cmTarget::ClearLinkMaps() -{ - this->LinkImplementationLanguageIsContextDependent = true; - this->Internal->LinkImplMap.clear(); - this->Internal->SourceFilesMap.clear(); -} - -//---------------------------------------------------------------------------- cmListFileBacktrace const& cmTarget::GetBacktrace() const { - return this->Internal->Backtrace; -} - -//---------------------------------------------------------------------------- -std::string cmTarget::GetSupportDirectory() const -{ - std::string dir = this->Makefile->GetCurrentBinaryDirectory(); - dir += cmake::GetCMakeFilesDirectory(); - dir += "/"; - dir += this->Name; -#if defined(__VMS) - dir += "_dir"; -#else - dir += ".dir"; -#endif - return dir; + return this->Backtrace; } //---------------------------------------------------------------------------- bool cmTarget::IsExecutableWithExports() const { - return (this->GetType() == cmTarget::EXECUTABLE && + return (this->GetType() == cmState::EXECUTABLE && this->GetPropertyAsBool("ENABLE_EXPORTS")); } //---------------------------------------------------------------------------- -bool cmTarget::IsLinkable() const -{ - return (this->GetType() == cmTarget::STATIC_LIBRARY || - this->GetType() == cmTarget::SHARED_LIBRARY || - this->GetType() == cmTarget::MODULE_LIBRARY || - this->GetType() == cmTarget::UNKNOWN_LIBRARY || - this->GetType() == cmTarget::INTERFACE_LIBRARY || - this->IsExecutableWithExports()); -} - -//---------------------------------------------------------------------------- bool cmTarget::HasImportLibrary() const { return (this->DLLPlatform && - (this->GetType() == cmTarget::SHARED_LIBRARY || + (this->GetType() == cmState::SHARED_LIBRARY || this->IsExecutableWithExports())); } //---------------------------------------------------------------------------- bool cmTarget::IsFrameworkOnApple() const { - return (this->GetType() == cmTarget::SHARED_LIBRARY && + return (this->GetType() == cmState::SHARED_LIBRARY && this->Makefile->IsOn("APPLE") && this->GetPropertyAsBool("FRAMEWORK")); } @@ -517,268 +344,19 @@ bool cmTarget::IsFrameworkOnApple() const //---------------------------------------------------------------------------- bool cmTarget::IsAppBundleOnApple() const { - return (this->GetType() == cmTarget::EXECUTABLE && + return (this->GetType() == cmState::EXECUTABLE && this->Makefile->IsOn("APPLE") && this->GetPropertyAsBool("MACOSX_BUNDLE")); } //---------------------------------------------------------------------------- -bool cmTarget::IsCFBundleOnApple() const -{ - return (this->GetType() == cmTarget::MODULE_LIBRARY && - this->Makefile->IsOn("APPLE") && - this->GetPropertyAsBool("BUNDLE")); -} - -//---------------------------------------------------------------------------- -bool cmTarget::IsXCTestOnApple() const -{ - return (this->IsCFBundleOnApple() && - this->GetPropertyAsBool("XCTEST")); -} - -//---------------------------------------------------------------------------- -static bool processSources(cmTarget const* tgt, - const std::vector<cmTargetInternals::TargetPropertyEntry*> &entries, - std::vector<std::string> &srcs, - UNORDERED_SET<std::string> &uniqueSrcs, - cmGeneratorExpressionDAGChecker *dagChecker, - std::string const& config, bool debugSources) -{ - cmMakefile *mf = tgt->GetMakefile(); - - bool contextDependent = false; - - for (std::vector<cmTargetInternals::TargetPropertyEntry*>::const_iterator - it = entries.begin(), end = entries.end(); it != end; ++it) - { - cmLinkImplItem const& item = (*it)->LinkImplItem; - std::string const& targetName = item; - std::vector<std::string> entrySources; - cmSystemTools::ExpandListArgument((*it)->ge->Evaluate(mf, - config, - false, - tgt, - tgt, - dagChecker), - entrySources); - - if ((*it)->ge->GetHadContextSensitiveCondition()) - { - contextDependent = true; - } - - for(std::vector<std::string>::iterator i = entrySources.begin(); - i != entrySources.end(); ++i) - { - std::string& src = *i; - cmSourceFile* sf = mf->GetOrCreateSource(src); - std::string e; - std::string fullPath = sf->GetFullPath(&e); - if(fullPath.empty()) - { - if(!e.empty()) - { - cmake* cm = mf->GetCMakeInstance(); - cm->IssueMessage(cmake::FATAL_ERROR, e, - tgt->GetBacktrace()); - } - return contextDependent; - } - - if (!targetName.empty() && !cmSystemTools::FileIsFullPath(src.c_str())) - { - std::ostringstream err; - if (!targetName.empty()) - { - err << "Target \"" << targetName << "\" contains relative " - "path in its INTERFACE_SOURCES:\n" - " \"" << src << "\""; - } - else - { - err << "Found relative path while evaluating sources of " - "\"" << tgt->GetName() << "\":\n \"" << src << "\"\n"; - } - tgt->GetMakefile()->IssueMessage(cmake::FATAL_ERROR, err.str()); - return contextDependent; - } - src = fullPath; - } - std::string usedSources; - for(std::vector<std::string>::iterator - li = entrySources.begin(); li != entrySources.end(); ++li) - { - std::string src = *li; - - if(uniqueSrcs.insert(src).second) - { - srcs.push_back(src); - if (debugSources) - { - usedSources += " * " + src + "\n"; - } - } - } - if (!usedSources.empty()) - { - mf->GetCMakeInstance()->IssueMessage(cmake::LOG, - std::string("Used sources for target ") - + tgt->GetName() + ":\n" - + usedSources, (*it)->ge->GetBacktrace()); - } - } - return contextDependent; -} - -//---------------------------------------------------------------------------- -void cmTarget::GetSourceFiles(std::vector<std::string> &files, - const std::string& config) const -{ - assert(this->GetType() != INTERFACE_LIBRARY); - - if (!this->GetMakefile()->GetGlobalGenerator()->GetConfigureDoneCMP0026()) - { - // At configure-time, this method can be called as part of getting the - // LOCATION property or to export() a file to be include()d. However - // there is no cmGeneratorTarget at configure-time, so search the SOURCES - // for TARGET_OBJECTS instead for backwards compatibility with OLD - // behavior of CMP0024 and CMP0026 only. - - typedef cmTargetInternals::TargetPropertyEntry - TargetPropertyEntry; - for(std::vector<TargetPropertyEntry*>::const_iterator - i = this->Internal->SourceEntries.begin(); - i != this->Internal->SourceEntries.end(); ++i) - { - std::string entry = (*i)->ge->GetInput(); - - std::vector<std::string> items; - cmSystemTools::ExpandListArgument(entry, items); - for (std::vector<std::string>::const_iterator - li = items.begin(); li != items.end(); ++li) - { - if(cmHasLiteralPrefix(*li, "$<TARGET_OBJECTS:") && - (*li)[li->size() - 1] == '>') - { - continue; - } - files.push_back(*li); - } - } - return; - } - - std::vector<std::string> debugProperties; - const char *debugProp = - this->Makefile->GetDefinition("CMAKE_DEBUG_TARGET_PROPERTIES"); - if (debugProp) - { - cmSystemTools::ExpandListArgument(debugProp, debugProperties); - } - - bool debugSources = !this->DebugSourcesDone - && std::find(debugProperties.begin(), - debugProperties.end(), - "SOURCES") - != debugProperties.end(); - - if (this->GetMakefile()->GetGlobalGenerator()->GetConfigureDoneCMP0026()) - { - this->DebugSourcesDone = true; - } - - cmGeneratorExpressionDAGChecker dagChecker(this->GetName(), - "SOURCES", 0, 0); - - UNORDERED_SET<std::string> uniqueSrcs; - bool contextDependentDirectSources = processSources(this, - this->Internal->SourceEntries, - files, - uniqueSrcs, - &dagChecker, - config, - debugSources); - - std::vector<cmTargetInternals::TargetPropertyEntry*> - linkInterfaceSourcesEntries; - - this->Internal->AddInterfaceEntries( - this, config, "INTERFACE_SOURCES", - linkInterfaceSourcesEntries); - - std::vector<std::string>::size_type numFilesBefore = files.size(); - bool contextDependentInterfaceSources = processSources(this, - linkInterfaceSourcesEntries, - files, - uniqueSrcs, - &dagChecker, - config, - debugSources); - - if (!contextDependentDirectSources - && !(contextDependentInterfaceSources && numFilesBefore < files.size())) - { - this->LinkImplementationLanguageIsContextDependent = false; - } - - cmDeleteAll(linkInterfaceSourcesEntries); -} - -//---------------------------------------------------------------------------- -void cmTarget::GetSourceFiles(std::vector<cmSourceFile*> &files, - const std::string& config) const -{ - - // Lookup any existing link implementation for this configuration. - std::string key = cmSystemTools::UpperCase(config); - - if(!this->LinkImplementationLanguageIsContextDependent) - { - files = this->Internal->SourceFilesMap.begin()->second; - return; - } - - cmTargetInternals::SourceFilesMapType::iterator - it = this->Internal->SourceFilesMap.find(key); - if(it != this->Internal->SourceFilesMap.end()) - { - files = it->second; - } - else - { - std::vector<std::string> srcs; - this->GetSourceFiles(srcs, config); - - std::set<cmSourceFile*> emitted; - - for(std::vector<std::string>::const_iterator i = srcs.begin(); - i != srcs.end(); ++i) - { - cmSourceFile* sf = this->Makefile->GetOrCreateSource(*i); - if (emitted.insert(sf).second) - { - files.push_back(sf); - } - } - this->Internal->SourceFilesMap[key] = files; - } -} - -//---------------------------------------------------------------------------- void cmTarget::AddTracedSources(std::vector<std::string> const& srcs) { - std::string srcFiles = cmJoin(srcs, ";"); - if (!srcFiles.empty()) + if (!srcs.empty()) { - this->Internal->SourceFilesMap.clear(); - this->LinkImplementationLanguageIsContextDependent = true; cmListFileBacktrace lfbt = this->Makefile->GetBacktrace(); - cmGeneratorExpression ge(lfbt); - cmsys::auto_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(srcFiles); - cge->SetEvaluateForBuildsystem(true); - this->Internal->SourceEntries.push_back( - new cmTargetInternals::TargetPropertyEntry(cge)); + this->Internal->SourceEntries.push_back(cmJoin(srcs, ";")); + this->Internal->SourceBacktraces.push_back(lfbt); } } @@ -811,14 +389,9 @@ void cmTarget::AddSources(std::vector<std::string> const& srcs) } if (!srcFiles.empty()) { - this->Internal->SourceFilesMap.clear(); - this->LinkImplementationLanguageIsContextDependent = true; cmListFileBacktrace lfbt = this->Makefile->GetBacktrace(); - cmGeneratorExpression ge(lfbt); - cmsys::auto_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(srcFiles); - cge->SetEvaluateForBuildsystem(true); - this->Internal->SourceEntries.push_back( - new cmTargetInternals::TargetPropertyEntry(cge)); + this->Internal->SourceEntries.push_back(srcFiles); + this->Internal->SourceBacktraces.push_back(lfbt); } } @@ -922,10 +495,10 @@ public: } - bool operator()(cmTargetInternals::TargetPropertyEntry* entry) + bool operator()(std::string const& entry) { std::vector<std::string> files; - cmSystemTools::ExpandListArgument(entry->ge->GetInput(), files); + cmSystemTools::ExpandListArgument(entry, files); std::vector<cmSourceFileLocation> locations(files.size()); std::transform(files.begin(), files.end(), locations.begin(), CreateLocation(this->Needle.GetMakefile())); @@ -944,14 +517,9 @@ cmSourceFile* cmTarget::AddSource(const std::string& src) TargetPropertyEntryFinder(sfl)) == this->Internal->SourceEntries.end()) { - this->Internal->SourceFilesMap.clear(); - this->LinkImplementationLanguageIsContextDependent = true; cmListFileBacktrace lfbt = this->Makefile->GetBacktrace(); - cmGeneratorExpression ge(lfbt); - cmsys::auto_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(src); - cge->SetEvaluateForBuildsystem(true); - this->Internal->SourceEntries.push_back( - new cmTargetInternals::TargetPropertyEntry(cge)); + this->Internal->SourceEntries.push_back(src); + this->Internal->SourceBacktraces.push_back(lfbt); } if (cmGeneratorExpression::Find(src) != std::string::npos) { @@ -996,31 +564,6 @@ const std::vector<std::string>& cmTarget::GetLinkDirectories() const } //---------------------------------------------------------------------------- -cmTarget::LinkLibraryType cmTarget::ComputeLinkType( - const std::string& config) const -{ - // No configuration is always optimized. - if(config.empty()) - { - return cmTarget::OPTIMIZED; - } - - // Get the list of configurations considered to be DEBUG. - std::vector<std::string> debugConfigs = - this->Makefile->GetCMakeInstance()->GetDebugConfigs(); - - // Check if any entry in the list matches this configuration. - std::string configUpper = cmSystemTools::UpperCase(config); - if (std::find(debugConfigs.begin(), debugConfigs.end(), configUpper) != - debugConfigs.end()) - { - return cmTarget::DEBUG; - } - // The current configuration is not a debug configuration. - return cmTarget::OPTIMIZED; -} - -//---------------------------------------------------------------------------- void cmTarget::ClearDependencyInformation( cmMakefile& mf, const std::string& target ) { @@ -1049,17 +592,10 @@ void cmTarget::ClearDependencyInformation( cmMakefile& mf, } //---------------------------------------------------------------------------- -bool cmTarget::NameResolvesToFramework(const std::string& libname) const -{ - return this->Makefile->GetGlobalGenerator()-> - NameResolvesToFramework(libname); -} - -//---------------------------------------------------------------------------- std::string cmTarget::GetDebugGeneratorExpressions(const std::string &value, - cmTarget::LinkLibraryType llt) const + cmTargetLinkLibraryType llt) const { - if (llt == GENERAL) + if (llt == GENERAL_LibraryType) { return value; } @@ -1080,7 +616,7 @@ std::string cmTarget::GetDebugGeneratorExpressions(const std::string &value, configString = "$<OR:" + configString + ">"; } - if (llt == OPTIMIZED) + if (llt == OPTIMIZED_LibraryType) { configString = "$<NOT:" + configString + ">"; } @@ -1137,22 +673,23 @@ void cmTarget::GetTllSignatureTraces(std::ostringstream &s, void cmTarget::AddLinkLibrary(cmMakefile& mf, const std::string& target, const std::string& lib, - LinkLibraryType llt) + cmTargetLinkLibraryType llt) { cmTarget *tgt = this->Makefile->FindTargetToUse(lib); { const bool isNonImportedTarget = tgt && !tgt->IsImported(); - const std::string libName = (isNonImportedTarget && llt != GENERAL) - ? targetNameGenex(lib) - : lib; + const std::string libName = + (isNonImportedTarget && llt != GENERAL_LibraryType) + ? targetNameGenex(lib) + : lib; this->AppendProperty("LINK_LIBRARIES", this->GetDebugGeneratorExpressions(libName, llt).c_str()); } if (cmGeneratorExpression::Find(lib) != std::string::npos - || (tgt && tgt->GetType() == INTERFACE_LIBRARY) + || (tgt && tgt->GetType() == cmState::INTERFACE_LIBRARY) || (target == lib )) { return; @@ -1165,7 +702,6 @@ void cmTarget::AddLinkLibrary(cmMakefile& mf, this->LinkLibrariesForVS6.push_back( tmp ); #endif this->OriginalLinkLibraries.push_back(tmp); - this->ClearLinkMaps(); // Add the explicit dependency information for this target. This is // simply a set of libraries separated by ";". There should always @@ -1187,13 +723,13 @@ void cmTarget::AddLinkLibrary(cmMakefile& mf, } switch (llt) { - case cmTarget::GENERAL: + case GENERAL_LibraryType: dependencies += "general"; break; - case cmTarget::DEBUG: + case DEBUG_LibraryType: dependencies += "debug"; break; - case cmTarget::OPTIMIZED: + case OPTIMIZED_LibraryType: dependencies += "optimized"; break; } @@ -1254,6 +790,26 @@ cmBacktraceRange cmTarget::GetCompileDefinitionsBacktraces() const return cmMakeRange(this->Internal->CompileDefinitionsBacktraces); } +cmStringRange cmTarget::GetSourceEntries() const +{ + return cmMakeRange(this->Internal->SourceEntries); +} + +cmBacktraceRange cmTarget::GetSourceBacktraces() const +{ + return cmMakeRange(this->Internal->SourceBacktraces); +} + +cmStringRange cmTarget::GetLinkImplementationEntries() const +{ + return cmMakeRange(this->Internal->LinkImplementationPropertyEntries); +} + +cmBacktraceRange cmTarget::GetLinkImplementationBacktraces() const +{ + return cmMakeRange(this->Internal->LinkImplementationPropertyBacktraces); +} + #if defined(_WIN32) && !defined(__CYGWIN__) //---------------------------------------------------------------------------- void @@ -1507,7 +1063,7 @@ void cmTarget::GatherDependenciesForVS6( const cmMakefile& mf, // Parse the dependency information, which is a set of // type, library pairs separated by ";". There is always a trailing ";". - cmTarget::LinkLibraryType llt = cmTarget::GENERAL; + cmTargetLinkLibraryType llt = GENERAL_LibraryType; std::string depline = deps; std::string::size_type start = 0; std::string::size_type end; @@ -1519,22 +1075,22 @@ void cmTarget::GatherDependenciesForVS6( const cmMakefile& mf, { if (l == "debug") { - llt = cmTarget::DEBUG; + llt = DEBUG_LibraryType; } else if (l == "optimized") { - llt = cmTarget::OPTIMIZED; + llt = OPTIMIZED_LibraryType; } else if (l == "general") { - llt = cmTarget::GENERAL; + llt = GENERAL_LibraryType; } else { LibraryID lib2(l,llt); this->InsertDependencyForVS6( dep_map, lib, lib2); this->GatherDependenciesForVS6( mf, lib2, dep_map); - llt = cmTarget::GENERAL; + llt = GENERAL_LibraryType; } } start = end+1; // skip the ; @@ -1582,7 +1138,7 @@ static bool whiteListedInterfaceProperty(const std::string& prop) //---------------------------------------------------------------------------- void cmTarget::SetProperty(const std::string& prop, const char* value) { - if (this->GetType() == INTERFACE_LIBRARY + if (this->GetType() == cmState::INTERFACE_LIBRARY && !whiteListedInterfaceProperty(prop)) { std::ostringstream e; @@ -1652,11 +1208,12 @@ void cmTarget::SetProperty(const std::string& prop, const char* value) else if (prop == "LINK_LIBRARIES") { this->Internal->LinkImplementationPropertyEntries.clear(); + this->Internal->LinkImplementationPropertyBacktraces.clear(); if (value) { cmListFileBacktrace lfbt = this->Makefile->GetBacktrace(); - cmValueWithOrigin entry(value, lfbt); - this->Internal->LinkImplementationPropertyEntries.push_back(entry); + this->Internal->LinkImplementationPropertyEntries.push_back(value); + this->Internal->LinkImplementationPropertyBacktraces.push_back(lfbt); } } else if (prop == "SOURCES") @@ -1669,19 +1226,19 @@ void cmTarget::SetProperty(const std::string& prop, const char* value) this->Makefile->IssueMessage(cmake::FATAL_ERROR, e.str()); return; } - this->Internal->SourceFilesMap.clear(); - cmListFileBacktrace lfbt = this->Makefile->GetBacktrace(); - cmGeneratorExpression ge(lfbt); - cmDeleteAll(this->Internal->SourceEntries); + this->Internal->SourceEntries.clear(); - cmsys::auto_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(value); - this->Internal->SourceEntries.push_back( - new cmTargetInternals::TargetPropertyEntry(cge)); + this->Internal->SourceBacktraces.clear(); + if (value) + { + cmListFileBacktrace lfbt = this->Makefile->GetBacktrace(); + this->Internal->SourceEntries.push_back(value); + this->Internal->SourceBacktraces.push_back(lfbt); + } } else { this->Properties.SetProperty(prop, value); - this->MaybeInvalidatePropertyCache(prop); } } @@ -1689,7 +1246,7 @@ void cmTarget::SetProperty(const std::string& prop, const char* value) void cmTarget::AppendProperty(const std::string& prop, const char* value, bool asString) { - if (this->GetType() == INTERFACE_LIBRARY + if (this->GetType() == cmState::INTERFACE_LIBRARY && !whiteListedInterfaceProperty(prop)) { std::ostringstream e; @@ -1753,8 +1310,8 @@ void cmTarget::AppendProperty(const std::string& prop, const char* value, if (value && *value) { cmListFileBacktrace lfbt = this->Makefile->GetBacktrace(); - cmValueWithOrigin entry(value, lfbt); - this->Internal->LinkImplementationPropertyEntries.push_back(entry); + this->Internal->LinkImplementationPropertyEntries.push_back(value); + this->Internal->LinkImplementationPropertyBacktraces.push_back(lfbt); } } else if (prop == "SOURCES") @@ -1767,47 +1324,23 @@ void cmTarget::AppendProperty(const std::string& prop, const char* value, this->Makefile->IssueMessage(cmake::FATAL_ERROR, e.str()); return; } - this->Internal->SourceFilesMap.clear(); cmListFileBacktrace lfbt = this->Makefile->GetBacktrace(); - cmGeneratorExpression ge(lfbt); - cmsys::auto_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(value); - this->Internal->SourceEntries.push_back( - new cmTargetInternals::TargetPropertyEntry(cge)); + this->Internal->SourceEntries.push_back(value); + this->Internal->SourceBacktraces.push_back(lfbt); } else { this->Properties.AppendProperty(prop, value, asString); - this->MaybeInvalidatePropertyCache(prop); - } -} - -//---------------------------------------------------------------------------- -std::string cmTarget::GetExportName() const -{ - const char *exportName = this->GetProperty("EXPORT_NAME"); - - if (exportName && *exportName) - { - if (!cmGeneratorExpression::IsValidTargetName(exportName)) - { - std::ostringstream e; - e << "EXPORT_NAME property \"" << exportName << "\" for \"" - << this->GetName() << "\": is not valid."; - cmSystemTools::Error(e.str().c_str()); - return ""; - } - return exportName; } - return this->GetName(); } //---------------------------------------------------------------------------- void cmTarget::AppendBuildInterfaceIncludes() { - if(this->GetType() != cmTarget::SHARED_LIBRARY && - this->GetType() != cmTarget::STATIC_LIBRARY && - this->GetType() != cmTarget::MODULE_LIBRARY && - this->GetType() != cmTarget::INTERFACE_LIBRARY && + if(this->GetType() != cmState::SHARED_LIBRARY && + this->GetType() != cmState::STATIC_LIBRARY && + this->GetType() != cmState::MODULE_LIBRARY && + this->GetType() != cmState::INTERFACE_LIBRARY && !this->IsExecutableWithExports()) { return; @@ -1876,20 +1409,6 @@ void cmTarget::InsertCompileDefinition(std::string const& entry, } //---------------------------------------------------------------------------- -void cmTarget::MaybeInvalidatePropertyCache(const std::string& prop) -{ - // Wipe out maps caching information affected by this property. - if(this->IsImported() && cmHasLiteralPrefix(prop, "IMPORTED")) - { - this->Internal->ImportInfoMap.clear(); - } - if(!this->IsImported() && cmHasLiteralPrefix(prop, "LINK_INTERFACE_")) - { - this->ClearLinkMaps(); - } -} - -//---------------------------------------------------------------------------- static void cmTargetCheckLINK_INTERFACE_LIBRARIES( const std::string& prop, const char* value, cmMakefile* context, bool imported) @@ -1984,157 +1503,10 @@ void cmTarget::CheckProperty(const std::string& prop, } //---------------------------------------------------------------------------- -void cmTarget::MarkAsImported() +void cmTarget::MarkAsImported(bool global) { this->IsImportedTarget = true; -} - -//---------------------------------------------------------------------------- -bool cmTarget::HaveWellDefinedOutputFiles() const -{ - return - this->GetType() == cmTarget::STATIC_LIBRARY || - this->GetType() == cmTarget::SHARED_LIBRARY || - this->GetType() == cmTarget::MODULE_LIBRARY || - this->GetType() == cmTarget::EXECUTABLE; -} - -//---------------------------------------------------------------------------- -cmTarget::OutputInfo const* cmTarget::GetOutputInfo( - const std::string& config) const -{ - // There is no output information for imported targets. - if(this->IsImported()) - { - return 0; - } - - // Only libraries and executables have well-defined output files. - if(!this->HaveWellDefinedOutputFiles()) - { - std::string msg = "cmTarget::GetOutputInfo called for "; - msg += this->GetName(); - msg += " which has type "; - msg += cmTarget::GetTargetTypeName(this->GetType()); - this->GetMakefile()->IssueMessage(cmake::INTERNAL_ERROR, msg); - return 0; - } - - // Lookup/compute/cache the output information for this configuration. - std::string config_upper; - if(!config.empty()) - { - config_upper = cmSystemTools::UpperCase(config); - } - typedef cmTargetInternals::OutputInfoMapType OutputInfoMapType; - OutputInfoMapType::iterator i = - this->Internal->OutputInfoMap.find(config_upper); - if(i == this->Internal->OutputInfoMap.end()) - { - // Add empty info in map to detect potential recursion. - OutputInfo info; - OutputInfoMapType::value_type entry(config_upper, info); - i = this->Internal->OutputInfoMap.insert(entry).first; - - // Compute output directories. - this->ComputeOutputDir(config, false, info.OutDir); - this->ComputeOutputDir(config, true, info.ImpDir); - if(!this->ComputePDBOutputDir("PDB", config, info.PdbDir)) - { - info.PdbDir = info.OutDir; - } - - // Now update the previously-prepared map entry. - i->second = info; - } - else if(i->second.empty()) - { - // An empty map entry indicates we have been called recursively - // from the above block. - this->Makefile->GetCMakeInstance()->IssueMessage( - cmake::FATAL_ERROR, - "Target '" + this->GetName() + "' OUTPUT_DIRECTORY depends on itself.", - this->GetBacktrace()); - return 0; - } - return &i->second; -} - -//---------------------------------------------------------------------------- -std::string cmTarget::GetDirectory(const std::string& config, - bool implib) const -{ - if (this->IsImported()) - { - // Return the directory from which the target is imported. - return - cmSystemTools::GetFilenamePath( - this->ImportedGetFullPath(config, implib)); - } - else if(OutputInfo const* info = this->GetOutputInfo(config)) - { - // Return the directory in which the target will be built. - return implib? info->ImpDir : info->OutDir; - } - return ""; -} - -//---------------------------------------------------------------------------- -std::string cmTarget::GetPDBDirectory(const std::string& config) const -{ - if(OutputInfo const* info = this->GetOutputInfo(config)) - { - // Return the directory in which the target will be built. - return info->PdbDir; - } - return ""; -} - -//---------------------------------------------------------------------------- -const char* cmTarget::ImportedGetLocation(const std::string& config) const -{ - static std::string location; - assert(this->IsImported()); - location = this->ImportedGetFullPath(config, false); - return location.c_str(); -} - -//---------------------------------------------------------------------------- -void cmTarget::GetTargetVersion(int& major, int& minor) const -{ - int patch; - this->GetTargetVersion(false, major, minor, patch); -} - -//---------------------------------------------------------------------------- -void cmTarget::GetTargetVersion(bool soversion, - int& major, int& minor, int& patch) const -{ - // Set the default values. - major = 0; - minor = 0; - patch = 0; - - assert(this->GetType() != INTERFACE_LIBRARY); - - // Look for a VERSION or SOVERSION property. - const char* prop = soversion? "SOVERSION" : "VERSION"; - if(const char* version = this->GetProperty(prop)) - { - // Try to parse the version number and store the results that were - // successfully parsed. - int parsed_major; - int parsed_minor; - int parsed_patch; - switch(sscanf(version, "%d.%d.%d", - &parsed_major, &parsed_minor, &parsed_patch)) - { - case 3: patch = parsed_patch; // no break! - case 2: minor = parsed_minor; // no break! - case 1: major = parsed_major; // no break! - default: break; - } - } + this->ImportedGloballyVisible = global; } //---------------------------------------------------------------------------- @@ -2183,7 +1555,7 @@ const char *cmTarget::GetProperty(const std::string& prop) const const char *cmTarget::GetProperty(const std::string& prop, cmMakefile* context) const { - if (this->GetType() == INTERFACE_LIBRARY + if (this->GetType() == cmState::INTERFACE_LIBRARY && !whiteListedInterfaceProperty(prop)) { std::ostringstream e; @@ -2195,11 +1567,11 @@ const char *cmTarget::GetProperty(const std::string& prop, // Watch for special "computed" properties that are dependent on // other properties or variables. Always recompute them. - if(this->GetType() == cmTarget::EXECUTABLE || - this->GetType() == cmTarget::STATIC_LIBRARY || - this->GetType() == cmTarget::SHARED_LIBRARY || - this->GetType() == cmTarget::MODULE_LIBRARY || - this->GetType() == cmTarget::UNKNOWN_LIBRARY) + if(this->GetType() == cmState::EXECUTABLE || + this->GetType() == cmState::STATIC_LIBRARY || + this->GetType() == cmState::SHARED_LIBRARY || + this->GetType() == cmState::MODULE_LIBRARY || + this->GetType() == cmState::UNKNOWN_LIBRARY) { static const std::string propLOCATION = "LOCATION"; if(prop == propLOCATION) @@ -2227,7 +1599,7 @@ const char *cmTarget::GetProperty(const std::string& prop, // CMake time. cmGlobalGenerator* gg = this->Makefile->GetGlobalGenerator(); gg->CreateGenerationObjects(); - cmGeneratorTarget* gt = gg->GetGeneratorTarget(this); + cmGeneratorTarget* gt = gg->FindGeneratorTarget(this->GetName()); this->Properties.SetProperty(propLOCATION, gt->GetLocationForBuild()); } @@ -2252,7 +1624,7 @@ const char *cmTarget::GetProperty(const std::string& prop, { cmGlobalGenerator* gg = this->Makefile->GetGlobalGenerator(); gg->CreateGenerationObjects(); - cmGeneratorTarget* gt = gg->GetGeneratorTarget(this); + cmGeneratorTarget* gt = gg->FindGeneratorTarget(this->GetName()); this->Properties.SetProperty( prop, gt->GetFullPath(configName, false).c_str()); } @@ -2276,7 +1648,7 @@ const char *cmTarget::GetProperty(const std::string& prop, { cmGlobalGenerator* gg = this->Makefile->GetGlobalGenerator(); gg->CreateGenerationObjects(); - cmGeneratorTarget* gt = gg->GetGeneratorTarget(this); + cmGeneratorTarget* gt = gg->FindGeneratorTarget(this->GetName()); this->Properties.SetProperty( prop, gt->GetFullPath(configName, false).c_str()); } @@ -2322,23 +1694,13 @@ const char *cmTarget::GetProperty(const std::string& prop, } static std::string output; - output = ""; - std::string sep; - for (std::vector<cmValueWithOrigin>::const_iterator - it = this->Internal->LinkImplementationPropertyEntries.begin(), - end = this->Internal->LinkImplementationPropertyEntries.end(); - it != end; ++it) - { - output += sep; - output += it->Value; - sep = ";"; - } + output = cmJoin(this->Internal->LinkImplementationPropertyEntries, ";"); return output.c_str(); } // the type property returns what type the target is else if (prop == propTYPE) { - return cmTarget::GetTargetTypeName(this->GetType()); + return cmState::GetTargetTypeName(this->GetType()); } else if(prop == propINCLUDE_DIRECTORIES) { @@ -2409,13 +1771,11 @@ const char *cmTarget::GetProperty(const std::string& prop, std::ostringstream ss; const char* sep = ""; - typedef cmTargetInternals::TargetPropertyEntry - TargetPropertyEntry; - for(std::vector<TargetPropertyEntry*>::const_iterator + for(std::vector<std::string>::const_iterator i = this->Internal->SourceEntries.begin(); i != this->Internal->SourceEntries.end(); ++i) { - std::string entry = (*i)->ge->GetInput(); + std::string const& entry = *i; std::vector<std::string> files; cmSystemTools::ExpandListArgument(entry, files); @@ -2521,17 +1881,17 @@ const char* cmTarget::GetSuffixVariableInternal(bool implib) const { switch(this->GetType()) { - case cmTarget::STATIC_LIBRARY: + case cmState::STATIC_LIBRARY: return "CMAKE_STATIC_LIBRARY_SUFFIX"; - case cmTarget::SHARED_LIBRARY: + case cmState::SHARED_LIBRARY: return (implib ? "CMAKE_IMPORT_LIBRARY_SUFFIX" : "CMAKE_SHARED_LIBRARY_SUFFIX"); - case cmTarget::MODULE_LIBRARY: + case cmState::MODULE_LIBRARY: return (implib ? "CMAKE_IMPORT_LIBRARY_SUFFIX" : "CMAKE_SHARED_MODULE_SUFFIX"); - case cmTarget::EXECUTABLE: + case cmState::EXECUTABLE: return (implib ? "CMAKE_IMPORT_LIBRARY_SUFFIX" // Android GUI application packages store the native @@ -2550,17 +1910,17 @@ const char* cmTarget::GetPrefixVariableInternal(bool implib) const { switch(this->GetType()) { - case cmTarget::STATIC_LIBRARY: + case cmState::STATIC_LIBRARY: return "CMAKE_STATIC_LIBRARY_PREFIX"; - case cmTarget::SHARED_LIBRARY: + case cmState::SHARED_LIBRARY: return (implib ? "CMAKE_IMPORT_LIBRARY_PREFIX" : "CMAKE_SHARED_LIBRARY_PREFIX"); - case cmTarget::MODULE_LIBRARY: + case cmState::MODULE_LIBRARY: return (implib ? "CMAKE_IMPORT_LIBRARY_PREFIX" : "CMAKE_SHARED_MODULE_PREFIX"); - case cmTarget::EXECUTABLE: + case cmState::EXECUTABLE: return (implib ? "CMAKE_IMPORT_LIBRARY_PREFIX" // Android GUI application packages store the native @@ -2574,148 +1934,76 @@ const char* cmTarget::GetPrefixVariableInternal(bool implib) const } //---------------------------------------------------------------------------- -bool cmTarget::HasMacOSXRpathInstallNameDir(const std::string& config) const +std::string +cmTarget::ImportedGetFullPath(const std::string& config, bool pimplib) const { - bool install_name_is_rpath = false; - bool macosx_rpath = false; + assert(this->IsImported()); - if(!this->IsImportedTarget) + // Lookup/compute/cache the import information for this + // configuration. + std::string config_upper; + if(!config.empty()) { - if(this->GetType() != cmTarget::SHARED_LIBRARY) - { - return false; - } - const char* install_name = this->GetProperty("INSTALL_NAME_DIR"); - bool use_install_name = - this->GetPropertyAsBool("BUILD_WITH_INSTALL_RPATH"); - if(install_name && use_install_name && - std::string(install_name) == "@rpath") - { - install_name_is_rpath = true; - } - else if(install_name && use_install_name) - { - return false; - } - if(!install_name_is_rpath) - { - macosx_rpath = this->MacOSXRpathInstallNameDirDefault(); - } + config_upper = cmSystemTools::UpperCase(config); } else { - // Lookup the imported soname. - if(cmTarget::ImportInfo const* info = this->GetImportInfo(config)) + config_upper = "NOCONFIG"; + } + + std::string result; + + const char* loc = 0; + const char* imp = 0; + std::string suffix; + + if(this->GetType() != cmState::INTERFACE_LIBRARY + && this->GetMappedConfig(config_upper, &loc, &imp, suffix)) + { + if (!pimplib) { - if(!info->NoSOName && !info->SOName.empty()) + if(loc) { - if(info->SOName.find("@rpath/") == 0) - { - install_name_is_rpath = true; - } + result = loc; } else { - std::string install_name; - cmSystemTools::GuessLibraryInstallName(info->Location, install_name); - if(install_name.find("@rpath") != std::string::npos) + std::string impProp = "IMPORTED_LOCATION"; + impProp += suffix; + if(const char* config_location = this->GetProperty(impProp)) + { + result = config_location; + } + else if(const char* location = + this->GetProperty("IMPORTED_LOCATION")) { - install_name_is_rpath = true; + result = location; } } } - } - - if(!install_name_is_rpath && !macosx_rpath) - { - return false; - } - - if(!this->Makefile->IsSet("CMAKE_SHARED_LIBRARY_RUNTIME_C_FLAG")) - { - std::ostringstream w; - w << "Attempting to use"; - if(macosx_rpath) - { - w << " MACOSX_RPATH"; - } else { - w << " @rpath"; - } - w << " without CMAKE_SHARED_LIBRARY_RUNTIME_C_FLAG being set."; - w << " This could be because you are using a Mac OS X version"; - w << " less than 10.5 or because CMake's platform configuration is"; - w << " corrupt."; - cmake* cm = this->Makefile->GetCMakeInstance(); - cm->IssueMessage(cmake::FATAL_ERROR, w.str(), this->GetBacktrace()); - } - - return true; -} - -//---------------------------------------------------------------------------- -bool cmTarget::MacOSXRpathInstallNameDirDefault() const -{ - // we can't do rpaths when unsupported - if(!this->Makefile->IsSet("CMAKE_SHARED_LIBRARY_RUNTIME_C_FLAG")) - { - return false; - } - - const char* macosx_rpath_str = this->GetProperty("MACOSX_RPATH"); - if(macosx_rpath_str) - { - return this->GetPropertyAsBool("MACOSX_RPATH"); - } - - cmPolicies::PolicyStatus cmp0042 = this->GetPolicyStatusCMP0042(); - - if(cmp0042 == cmPolicies::WARN) - { - this->Makefile->GetGlobalGenerator()-> - AddCMP0042WarnTarget(this->GetName()); - } - - if(cmp0042 == cmPolicies::NEW) - { - return true; - } - - return false; -} - -//---------------------------------------------------------------------------- -bool cmTarget::IsImportedSharedLibWithoutSOName( - const std::string& config) const -{ - if(this->IsImported() && this->GetType() == cmTarget::SHARED_LIBRARY) - { - if(cmTarget::ImportInfo const* info = this->GetImportInfo(config)) - { - return info->NoSOName; + if(imp) + { + result = imp; + } + else if(this->GetType() == cmState::SHARED_LIBRARY || + this->IsExecutableWithExports()) + { + std::string impProp = "IMPORTED_IMPLIB"; + impProp += suffix; + if(const char* config_implib = this->GetProperty(impProp)) + { + result = config_implib; + } + else if(const char* implib = this->GetProperty("IMPORTED_IMPLIB")) + { + result = implib; + } + } } } - return false; -} - -//---------------------------------------------------------------------------- -std::string -cmTarget::GetFullNameImported(const std::string& config, bool implib) const -{ - return cmSystemTools::GetFilenameName( - this->ImportedGetFullPath(config, implib)); -} -//---------------------------------------------------------------------------- -std::string -cmTarget::ImportedGetFullPath(const std::string& config, bool implib) const -{ - std::string result; - if(cmTarget::ImportInfo const* info = this->GetImportInfo(config)) - { - result = implib? info->ImportLibrary : info->Location; - } if(result.empty()) { result = this->GetName(); @@ -2725,43 +2013,6 @@ cmTarget::ImportedGetFullPath(const std::string& config, bool implib) const } //---------------------------------------------------------------------------- -void cmTarget::ComputeVersionedName(std::string& vName, - std::string const& prefix, - std::string const& base, - std::string const& suffix, - std::string const& name, - const char* version) const -{ - vName = this->IsApple? (prefix+base) : name; - if(version) - { - vName += "."; - vName += version; - } - vName += this->IsApple? suffix : std::string(); -} - -//---------------------------------------------------------------------------- -bool cmTarget::HasImplibGNUtoMS() const -{ - return this->HasImportLibrary() && this->GetPropertyAsBool("GNUtoMS"); -} - -//---------------------------------------------------------------------------- -bool cmTarget::GetImplibGNUtoMS(std::string const& gnuName, - std::string& out, const char* newExt) const -{ - if(this->HasImplibGNUtoMS() && - gnuName.size() > 6 && gnuName.substr(gnuName.size()-6) == ".dll.a") - { - out = gnuName.substr(0, gnuName.size()-6); - out += newExt? newExt : ".lib"; - return true; - } - return false; -} - -//---------------------------------------------------------------------------- void cmTarget::SetPropertyDefault(const std::string& property, const char* default_value) { @@ -2779,383 +2030,15 @@ void cmTarget::SetPropertyDefault(const std::string& property, } } -//---------------------------------------------------------------------------- -bool cmTarget::HaveInstallTreeRPATH() const -{ - const char* install_rpath = this->GetProperty("INSTALL_RPATH"); - return (install_rpath && *install_rpath) && - !this->Makefile->IsOn("CMAKE_SKIP_INSTALL_RPATH"); -} - -//---------------------------------------------------------------------------- -const char* cmTarget::GetOutputTargetType(bool implib) const -{ - switch(this->GetType()) - { - case cmTarget::SHARED_LIBRARY: - if(this->DLLPlatform) - { - if(implib) - { - // A DLL import library is treated as an archive target. - return "ARCHIVE"; - } - else - { - // A DLL shared library is treated as a runtime target. - return "RUNTIME"; - } - } - else - { - // For non-DLL platforms shared libraries are treated as - // library targets. - return "LIBRARY"; - } - case cmTarget::STATIC_LIBRARY: - // Static libraries are always treated as archive targets. - return "ARCHIVE"; - case cmTarget::MODULE_LIBRARY: - if(implib) - { - // Module libraries are always treated as library targets. - return "ARCHIVE"; - } - else - { - // Module import libraries are treated as archive targets. - return "LIBRARY"; - } - case cmTarget::EXECUTABLE: - if(implib) - { - // Executable import libraries are treated as archive targets. - return "ARCHIVE"; - } - else - { - // Executables are always treated as runtime targets. - return "RUNTIME"; - } - default: - break; - } - return ""; -} - -//---------------------------------------------------------------------------- -bool cmTarget::ComputeOutputDir(const std::string& config, - bool implib, std::string& out) const -{ - bool usesDefaultOutputDir = false; - std::string conf = config; - - // Look for a target property defining the target output directory - // based on the target type. - std::string targetTypeName = this->GetOutputTargetType(implib); - const char* propertyName = 0; - std::string propertyNameStr = targetTypeName; - if(!propertyNameStr.empty()) - { - propertyNameStr += "_OUTPUT_DIRECTORY"; - propertyName = propertyNameStr.c_str(); - } - - // Check for a per-configuration output directory target property. - std::string configUpper = cmSystemTools::UpperCase(conf); - const char* configProp = 0; - std::string configPropStr = targetTypeName; - if(!configPropStr.empty()) - { - configPropStr += "_OUTPUT_DIRECTORY_"; - configPropStr += configUpper; - configProp = configPropStr.c_str(); - } - - // Select an output directory. - if(const char* config_outdir = this->GetProperty(configProp)) - { - // Use the user-specified per-configuration output directory. - cmGeneratorExpression ge; - cmsys::auto_ptr<cmCompiledGeneratorExpression> cge = - ge.Parse(config_outdir); - out = cge->Evaluate(this->Makefile, config); - - // Skip per-configuration subdirectory. - conf = ""; - } - else if(const char* outdir = this->GetProperty(propertyName)) - { - // Use the user-specified output directory. - cmGeneratorExpression ge; - cmsys::auto_ptr<cmCompiledGeneratorExpression> cge = - ge.Parse(outdir); - out = cge->Evaluate(this->Makefile, config); - - // Skip per-configuration subdirectory if the value contained a - // generator expression. - if (out != outdir) - { - conf = ""; - } - } - else if(this->GetType() == cmTarget::EXECUTABLE) - { - // Lookup the output path for executables. - out = this->Makefile->GetSafeDefinition("EXECUTABLE_OUTPUT_PATH"); - } - else if(this->GetType() == cmTarget::STATIC_LIBRARY || - this->GetType() == cmTarget::SHARED_LIBRARY || - this->GetType() == cmTarget::MODULE_LIBRARY) - { - // Lookup the output path for libraries. - out = this->Makefile->GetSafeDefinition("LIBRARY_OUTPUT_PATH"); - } - if(out.empty()) - { - // Default to the current output directory. - usesDefaultOutputDir = true; - out = "."; - } - - // Convert the output path to a full path in case it is - // specified as a relative path. Treat a relative path as - // relative to the current output directory for this makefile. - out = (cmSystemTools::CollapseFullPath - (out, this->Makefile->GetCurrentBinaryDirectory())); - - // The generator may add the configuration's subdirectory. - if(!conf.empty()) - { - bool iosPlatform = this->Makefile->PlatformIsAppleIos(); - std::string suffix = - usesDefaultOutputDir && iosPlatform ? "${EFFECTIVE_PLATFORM_NAME}" : ""; - this->Makefile->GetGlobalGenerator()-> - AppendDirectoryForConfig("/", conf, suffix, out); - } - - return usesDefaultOutputDir; -} - -//---------------------------------------------------------------------------- -bool cmTarget::ComputePDBOutputDir(const std::string& kind, - const std::string& config, - std::string& out) const -{ - // Look for a target property defining the target output directory - // based on the target type. - const char* propertyName = 0; - std::string propertyNameStr = kind; - if(!propertyNameStr.empty()) - { - propertyNameStr += "_OUTPUT_DIRECTORY"; - propertyName = propertyNameStr.c_str(); - } - std::string conf = config; - - // Check for a per-configuration output directory target property. - std::string configUpper = cmSystemTools::UpperCase(conf); - const char* configProp = 0; - std::string configPropStr = kind; - if(!configPropStr.empty()) - { - configPropStr += "_OUTPUT_DIRECTORY_"; - configPropStr += configUpper; - configProp = configPropStr.c_str(); - } - - // Select an output directory. - if(const char* config_outdir = this->GetProperty(configProp)) - { - // Use the user-specified per-configuration output directory. - out = config_outdir; - - // Skip per-configuration subdirectory. - conf = ""; - } - else if(const char* outdir = this->GetProperty(propertyName)) - { - // Use the user-specified output directory. - out = outdir; - } - if(out.empty()) - { - return false; - } - - // Convert the output path to a full path in case it is - // specified as a relative path. Treat a relative path as - // relative to the current output directory for this makefile. - out = (cmSystemTools::CollapseFullPath - (out, this->Makefile->GetCurrentBinaryDirectory())); - - // The generator may add the configuration's subdirectory. - if(!conf.empty()) - { - this->Makefile->GetGlobalGenerator()-> - AppendDirectoryForConfig("/", conf, "", out); - } - return true; -} - -//---------------------------------------------------------------------------- -bool cmTarget::UsesDefaultOutputDir(const std::string& config, - bool implib) const -{ - std::string dir; - return this->ComputeOutputDir(config, implib, dir); -} - -//---------------------------------------------------------------------------- -std::string cmTarget::GetFrameworkVersion() const -{ - assert(this->GetType() != INTERFACE_LIBRARY); - - if(const char* fversion = this->GetProperty("FRAMEWORK_VERSION")) - { - return fversion; - } - else if(const char* tversion = this->GetProperty("VERSION")) - { - return tversion; - } - else - { - return "A"; - } -} - -//---------------------------------------------------------------------------- -const char* cmTarget::GetExportMacro() const -{ - // Define the symbol for targets that export symbols. - if(this->GetType() == cmTarget::SHARED_LIBRARY || - this->GetType() == cmTarget::MODULE_LIBRARY || - this->IsExecutableWithExports()) - { - if(const char* custom_export_name = this->GetProperty("DEFINE_SYMBOL")) - { - this->ExportMacro = custom_export_name; - } - else - { - std::string in = this->GetName(); - in += "_EXPORTS"; - this->ExportMacro = cmSystemTools::MakeCindentifier(in); - } - return this->ExportMacro.c_str(); - } - else - { - return 0; - } -} - -//---------------------------------------------------------------------------- -bool cmTarget::IsNullImpliedByLinkLibraries(const std::string &p) const -{ - return this->LinkImplicitNullProperties.find(p) - != this->LinkImplicitNullProperties.end(); -} - -//---------------------------------------------------------------------------- -void -cmTarget::GetObjectLibrariesCMP0026(std::vector<cmTarget*>& objlibs) const -{ - // At configure-time, this method can be called as part of getting the - // LOCATION property or to export() a file to be include()d. However - // there is no cmGeneratorTarget at configure-time, so search the SOURCES - // for TARGET_OBJECTS instead for backwards compatibility with OLD - // behavior of CMP0024 and CMP0026 only. - typedef cmTargetInternals::TargetPropertyEntry - TargetPropertyEntry; - for(std::vector<TargetPropertyEntry*>::const_iterator - i = this->Internal->SourceEntries.begin(); - i != this->Internal->SourceEntries.end(); ++i) - { - std::string entry = (*i)->ge->GetInput(); - - std::vector<std::string> files; - cmSystemTools::ExpandListArgument(entry, files); - for (std::vector<std::string>::const_iterator - li = files.begin(); li != files.end(); ++li) - { - if(cmHasLiteralPrefix(*li, "$<TARGET_OBJECTS:") && - (*li)[li->size() - 1] == '>') - { - std::string objLibName = li->substr(17, li->size()-18); - - if (cmGeneratorExpression::Find(objLibName) != std::string::npos) - { - continue; - } - cmTarget *objLib = this->Makefile->FindTargetToUse(objLibName); - if(objLib) - { - objlibs.push_back(objLib); - } - } - } - } -} - -//---------------------------------------------------------------------------- -cmTarget::ImportInfo const* -cmTarget::GetImportInfo(const std::string& config) const -{ - // There is no imported information for non-imported targets. - if(!this->IsImported()) - { - return 0; - } - - // Lookup/compute/cache the import information for this - // configuration. - std::string config_upper; - if(!config.empty()) - { - config_upper = cmSystemTools::UpperCase(config); - } - else - { - config_upper = "NOCONFIG"; - } - typedef cmTargetInternals::ImportInfoMapType ImportInfoMapType; - - ImportInfoMapType::const_iterator i = - this->Internal->ImportInfoMap.find(config_upper); - if(i == this->Internal->ImportInfoMap.end()) - { - ImportInfo info; - this->ComputeImportInfo(config_upper, info); - ImportInfoMapType::value_type entry(config_upper, info); - i = this->Internal->ImportInfoMap.insert(entry).first; - } - - if(this->GetType() == INTERFACE_LIBRARY) - { - return &i->second; - } - // If the location is empty then the target is not available for - // this configuration. - if(i->second.Location.empty() && i->second.ImportLibrary.empty()) - { - return 0; - } - - // Return the import information. - return &i->second; -} - bool cmTarget::GetMappedConfig(std::string const& desired_config, const char** loc, const char** imp, std::string& suffix) const { - if (this->GetType() == INTERFACE_LIBRARY) + if (this->GetType() == cmState::INTERFACE_LIBRARY) { // This method attempts to find a config-specific LOCATION for the - // IMPORTED library. In the case of INTERFACE_LIBRARY, there is no + // IMPORTED library. In the case of cmState::INTERFACE_LIBRARY, there is no // LOCATION at all, so leaving *loc and *imp unchanged is the appropriate // and valid response. return true; @@ -3279,445 +2162,6 @@ bool cmTarget::GetMappedConfig(std::string const& desired_config, } //---------------------------------------------------------------------------- -void cmTarget::ComputeImportInfo(std::string const& desired_config, - ImportInfo& info) const -{ - // This method finds information about an imported target from its - // properties. The "IMPORTED_" namespace is reserved for properties - // defined by the project exporting the target. - - // Initialize members. - info.NoSOName = false; - - const char* loc = 0; - const char* imp = 0; - std::string suffix; - if (!this->GetMappedConfig(desired_config, &loc, &imp, suffix)) - { - return; - } - - // Get the link interface. - { - std::string linkProp = "INTERFACE_LINK_LIBRARIES"; - const char *propertyLibs = this->GetProperty(linkProp); - - if (this->GetType() != INTERFACE_LIBRARY) - { - if(!propertyLibs) - { - linkProp = "IMPORTED_LINK_INTERFACE_LIBRARIES"; - linkProp += suffix; - propertyLibs = this->GetProperty(linkProp); - } - - if(!propertyLibs) - { - linkProp = "IMPORTED_LINK_INTERFACE_LIBRARIES"; - propertyLibs = this->GetProperty(linkProp); - } - } - if(propertyLibs) - { - info.LibrariesProp = linkProp; - info.Libraries = propertyLibs; - } - } - if(this->GetType() == INTERFACE_LIBRARY) - { - return; - } - - // A provided configuration has been chosen. Load the - // configuration's properties. - - // Get the location. - if(loc) - { - info.Location = loc; - } - else - { - std::string impProp = "IMPORTED_LOCATION"; - impProp += suffix; - if(const char* config_location = this->GetProperty(impProp)) - { - info.Location = config_location; - } - else if(const char* location = this->GetProperty("IMPORTED_LOCATION")) - { - info.Location = location; - } - } - - // Get the soname. - if(this->GetType() == cmTarget::SHARED_LIBRARY) - { - std::string soProp = "IMPORTED_SONAME"; - soProp += suffix; - if(const char* config_soname = this->GetProperty(soProp)) - { - info.SOName = config_soname; - } - else if(const char* soname = this->GetProperty("IMPORTED_SONAME")) - { - info.SOName = soname; - } - } - - // Get the "no-soname" mark. - if(this->GetType() == cmTarget::SHARED_LIBRARY) - { - std::string soProp = "IMPORTED_NO_SONAME"; - soProp += suffix; - if(const char* config_no_soname = this->GetProperty(soProp)) - { - info.NoSOName = cmSystemTools::IsOn(config_no_soname); - } - else if(const char* no_soname = this->GetProperty("IMPORTED_NO_SONAME")) - { - info.NoSOName = cmSystemTools::IsOn(no_soname); - } - } - - // Get the import library. - if(imp) - { - info.ImportLibrary = imp; - } - else if(this->GetType() == cmTarget::SHARED_LIBRARY || - this->IsExecutableWithExports()) - { - std::string impProp = "IMPORTED_IMPLIB"; - impProp += suffix; - if(const char* config_implib = this->GetProperty(impProp)) - { - info.ImportLibrary = config_implib; - } - else if(const char* implib = this->GetProperty("IMPORTED_IMPLIB")) - { - info.ImportLibrary = implib; - } - } - - // Get the link dependencies. - { - std::string linkProp = "IMPORTED_LINK_DEPENDENT_LIBRARIES"; - linkProp += suffix; - if(const char* config_libs = this->GetProperty(linkProp)) - { - info.SharedDeps = config_libs; - } - else if(const char* libs = - this->GetProperty("IMPORTED_LINK_DEPENDENT_LIBRARIES")) - { - info.SharedDeps = libs; - } - } - - // Get the link languages. - if(this->LinkLanguagePropagatesToDependents()) - { - std::string linkProp = "IMPORTED_LINK_INTERFACE_LANGUAGES"; - linkProp += suffix; - if(const char* config_libs = this->GetProperty(linkProp)) - { - info.Languages = config_libs; - } - else if(const char* libs = - this->GetProperty("IMPORTED_LINK_INTERFACE_LANGUAGES")) - { - info.Languages = libs; - } - } - - // Get the cyclic repetition count. - if(this->GetType() == cmTarget::STATIC_LIBRARY) - { - std::string linkProp = "IMPORTED_LINK_INTERFACE_MULTIPLICITY"; - linkProp += suffix; - if(const char* config_reps = this->GetProperty(linkProp)) - { - sscanf(config_reps, "%u", &info.Multiplicity); - } - else if(const char* reps = - this->GetProperty("IMPORTED_LINK_INTERFACE_MULTIPLICITY")) - { - sscanf(reps, "%u", &info.Multiplicity); - } - } -} - -//---------------------------------------------------------------------------- -void cmTargetInternals::AddInterfaceEntries( - cmTarget const* thisTarget, std::string const& config, - std::string const& prop, std::vector<TargetPropertyEntry*>& entries) -{ - if(cmLinkImplementationLibraries const* impl = - thisTarget->GetLinkImplementationLibraries(config)) - { - for (std::vector<cmLinkImplItem>::const_iterator - it = impl->Libraries.begin(), end = impl->Libraries.end(); - it != end; ++it) - { - if(it->Target) - { - std::string genex = - "$<TARGET_PROPERTY:" + *it + "," + prop + ">"; - cmGeneratorExpression ge(it->Backtrace); - cmsys::auto_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(genex); - cge->SetEvaluateForBuildsystem(true); - entries.push_back( - new cmTargetInternals::TargetPropertyEntry(cge, *it)); - } - } - } -} - -cmOptionalLinkImplementation& -cmTarget::GetLinkImplMap(std::string const& config) const -{ - // Populate the link implementation for this configuration. - std::string CONFIG = cmSystemTools::UpperCase(config); - return Internal->LinkImplMap[CONFIG][this]; -} - -//---------------------------------------------------------------------------- -cmLinkImplementationLibraries const* -cmTarget::GetLinkImplementationLibraries(const std::string& config) const -{ - return this->GetLinkImplementationLibrariesInternal(config, this); -} - -//---------------------------------------------------------------------------- -cmLinkImplementationLibraries const* -cmTarget::GetLinkImplementationLibrariesInternal(const std::string& config, - cmTarget const* head) const -{ - // There is no link implementation for imported targets. - if(this->IsImported()) - { - return 0; - } - - // Populate the link implementation libraries for this configuration. - std::string CONFIG = cmSystemTools::UpperCase(config); - cmTargetInternals::HeadToLinkImplementationMap& hm = - this->Internal->LinkImplMap[CONFIG]; - - // If the link implementation does not depend on the head target - // then return the one we computed first. - if(!hm.empty() && !hm.begin()->second.HadHeadSensitiveCondition) - { - return &hm.begin()->second; - } - - cmOptionalLinkImplementation& impl = hm[head]; - if(!impl.LibrariesDone) - { - impl.LibrariesDone = true; - this->ComputeLinkImplementationLibraries(config, impl, head); - } - return &impl; -} - -//---------------------------------------------------------------------------- -void cmTarget::ComputeLinkImplementationLibraries( - const std::string& config, - cmOptionalLinkImplementation& impl, - cmTarget const* head) const -{ - // Collect libraries directly linked in this configuration. - for (std::vector<cmValueWithOrigin>::const_iterator - le = this->Internal->LinkImplementationPropertyEntries.begin(), - end = this->Internal->LinkImplementationPropertyEntries.end(); - le != end; ++le) - { - std::vector<std::string> llibs; - cmGeneratorExpressionDAGChecker dagChecker( - this->GetName(), - "LINK_LIBRARIES", 0, 0); - cmGeneratorExpression ge(le->Backtrace); - cmsys::auto_ptr<cmCompiledGeneratorExpression> const cge = - ge.Parse(le->Value); - std::string const evaluated = - cge->Evaluate(this->Makefile, config, false, head, &dagChecker); - cmSystemTools::ExpandListArgument(evaluated, llibs); - if(cge->GetHadHeadSensitiveCondition()) - { - impl.HadHeadSensitiveCondition = true; - } - - for(std::vector<std::string>::const_iterator li = llibs.begin(); - li != llibs.end(); ++li) - { - // Skip entries that resolve to the target itself or are empty. - std::string name = this->CheckCMP0004(*li); - if(name == this->GetName() || name.empty()) - { - if(name == this->GetName()) - { - bool noMessage = false; - cmake::MessageType messageType = cmake::FATAL_ERROR; - std::ostringstream e; - switch(this->GetPolicyStatusCMP0038()) - { - case cmPolicies::WARN: - { - e << cmPolicies::GetPolicyWarning(cmPolicies::CMP0038) << "\n"; - messageType = cmake::AUTHOR_WARNING; - } - break; - case cmPolicies::OLD: - noMessage = true; - case cmPolicies::REQUIRED_IF_USED: - case cmPolicies::REQUIRED_ALWAYS: - case cmPolicies::NEW: - // Issue the fatal message. - break; - } - - if(!noMessage) - { - e << "Target \"" << this->GetName() << "\" links to itself."; - this->Makefile->GetCMakeInstance()->IssueMessage( - messageType, e.str(), this->GetBacktrace()); - if (messageType == cmake::FATAL_ERROR) - { - return; - } - } - } - continue; - } - - // The entry is meant for this configuration. - impl.Libraries.push_back( - cmLinkImplItem(name, this->FindTargetToLink(name), - le->Backtrace, evaluated != le->Value)); - } - - std::set<std::string> const& seenProps = cge->GetSeenTargetProperties(); - for (std::set<std::string>::const_iterator it = seenProps.begin(); - it != seenProps.end(); ++it) - { - if (!this->GetProperty(*it)) - { - this->LinkImplicitNullProperties.insert(*it); - } - } - cge->GetMaxLanguageStandard(this, this->MaxLanguageStandards); - } - - cmTarget::LinkLibraryType linkType = this->ComputeLinkType(config); - cmTarget::LinkLibraryVectorType const& oldllibs = - this->GetOriginalLinkLibraries(); - for(cmTarget::LinkLibraryVectorType::const_iterator li = oldllibs.begin(); - li != oldllibs.end(); ++li) - { - if(li->second != cmTarget::GENERAL && li->second != linkType) - { - std::string name = this->CheckCMP0004(li->first); - if(name == this->GetName() || name.empty()) - { - continue; - } - // Support OLD behavior for CMP0003. - impl.WrongConfigLibraries.push_back( - cmLinkItem(name, this->FindTargetToLink(name))); - } - } -} - -//---------------------------------------------------------------------------- -cmTarget const* cmTarget::FindTargetToLink(std::string const& name) const -{ - cmTarget const* tgt = this->Makefile->FindTargetToUse(name); - - // Skip targets that will not really be linked. This is probably a - // name conflict between an external library and an executable - // within the project. - if(tgt && tgt->GetType() == cmTarget::EXECUTABLE && - !tgt->IsExecutableWithExports()) - { - tgt = 0; - } - - if(tgt && tgt->GetType() == cmTarget::OBJECT_LIBRARY) - { - std::ostringstream e; - e << "Target \"" << this->GetName() << "\" links to " - "OBJECT library \"" << tgt->GetName() << "\" but this is not " - "allowed. " - "One may link only to STATIC or SHARED libraries, or to executables " - "with the ENABLE_EXPORTS property set."; - cmake* cm = this->Makefile->GetCMakeInstance(); - cm->IssueMessage(cmake::FATAL_ERROR, e.str(), this->GetBacktrace()); - tgt = 0; - } - - // Return the target found, if any. - return tgt; -} - -//---------------------------------------------------------------------------- -std::string cmTarget::CheckCMP0004(std::string const& item) const -{ - // Strip whitespace off the library names because we used to do this - // in case variables were expanded at generate time. We no longer - // do the expansion but users link to libraries like " ${VAR} ". - std::string lib = item; - std::string::size_type pos = lib.find_first_not_of(" \t\r\n"); - if(pos != lib.npos) - { - lib = lib.substr(pos, lib.npos); - } - pos = lib.find_last_not_of(" \t\r\n"); - if(pos != lib.npos) - { - lib = lib.substr(0, pos+1); - } - if(lib != item) - { - cmake* cm = this->Makefile->GetCMakeInstance(); - switch(this->GetPolicyStatusCMP0004()) - { - case cmPolicies::WARN: - { - std::ostringstream w; - w << cmPolicies::GetPolicyWarning(cmPolicies::CMP0004) << "\n" - << "Target \"" << this->GetName() << "\" links to item \"" - << item << "\" which has leading or trailing whitespace."; - cm->IssueMessage(cmake::AUTHOR_WARNING, w.str(), - this->GetBacktrace()); - } - case cmPolicies::OLD: - break; - case cmPolicies::NEW: - { - std::ostringstream e; - e << "Target \"" << this->GetName() << "\" links to item \"" - << item << "\" which has leading or trailing whitespace. " - << "This is now an error according to policy CMP0004."; - cm->IssueMessage(cmake::FATAL_ERROR, e.str(), this->GetBacktrace()); - } - break; - case cmPolicies::REQUIRED_IF_USED: - case cmPolicies::REQUIRED_ALWAYS: - { - std::ostringstream e; - e << cmPolicies::GetRequiredPolicyError(cmPolicies::CMP0004) << "\n" - << "Target \"" << this->GetName() << "\" links to item \"" - << item << "\" which has leading or trailing whitespace."; - cm->IssueMessage(cmake::FATAL_ERROR, e.str(), this->GetBacktrace()); - } - break; - } - } - return lib; -} - -//---------------------------------------------------------------------------- cmTargetInternalPointer::cmTargetInternalPointer() { this->Pointer = new cmTargetInternals; @@ -3736,7 +2180,6 @@ cmTargetInternalPointer //---------------------------------------------------------------------------- cmTargetInternalPointer::~cmTargetInternalPointer() { - cmDeleteAll(this->Pointer->SourceEntries); delete this->Pointer; } diff --git a/Source/cmTarget.h b/Source/cmTarget.h index 3e71dbd..97b0871 100644 --- a/Source/cmTarget.h +++ b/Source/cmTarget.h @@ -16,7 +16,6 @@ #include "cmPropertyMap.h" #include "cmPolicies.h" #include "cmListFileCache.h" -#include "cmLinkItem.h" #include <cmsys/auto_ptr.hxx> #if defined(CMAKE_BUILD_WITH_CMAKE) @@ -27,28 +26,10 @@ # endif #endif -#define CM_FOR_EACH_TARGET_POLICY(F) \ - F(CMP0003) \ - F(CMP0004) \ - F(CMP0008) \ - F(CMP0020) \ - F(CMP0021) \ - F(CMP0022) \ - F(CMP0027) \ - F(CMP0038) \ - F(CMP0041) \ - F(CMP0042) \ - F(CMP0046) \ - F(CMP0052) \ - F(CMP0060) \ - F(CMP0063) \ - F(CMP0065) - class cmake; class cmMakefile; class cmSourceFile; class cmGlobalGenerator; -class cmComputeLinkInformation; class cmListFileBacktrace; class cmTarget; class cmGeneratorTarget; @@ -78,18 +59,12 @@ class cmTarget { public: cmTarget(); - enum TargetType { EXECUTABLE, STATIC_LIBRARY, - SHARED_LIBRARY, MODULE_LIBRARY, - OBJECT_LIBRARY, UTILITY, GLOBAL_TARGET, - INTERFACE_LIBRARY, - UNKNOWN_LIBRARY}; - static const char* GetTargetTypeName(TargetType targetType); enum CustomCommandType { PRE_BUILD, PRE_LINK, POST_BUILD }; /** * Return the type of target. */ - TargetType GetType() const + cmState::TargetType GetType() const { return this->TargetTypeValue; } @@ -97,13 +72,12 @@ public: /** * Set the target type */ - void SetType(TargetType f, const std::string& name); + void SetType(cmState::TargetType f, const std::string& name); - void MarkAsImported(); + void MarkAsImported(bool global = false); ///! Set/Get the name of the target const std::string& GetName() const {return this->Name;} - std::string GetExportName() const; ///! Set the cmMakefile that owns this target void SetMakefile(cmMakefile *mf); @@ -134,11 +108,6 @@ public: {this->PostBuildCommands.push_back(cmd);} /** - * Get the list of the source files used by this target - */ - void GetSourceFiles(std::vector<cmSourceFile*> &files, - const std::string& config) const; - /** * Add sources to the target. */ void AddSources(std::vector<std::string> const& srcs); @@ -146,28 +115,21 @@ public: cmSourceFile* AddSourceCMP0049(const std::string& src); cmSourceFile* AddSource(const std::string& src); - enum LinkLibraryType {GENERAL, DEBUG, OPTIMIZED}; - //* how we identify a library, by name and type - typedef std::pair<std::string, LinkLibraryType> LibraryID; + typedef std::pair<std::string, cmTargetLinkLibraryType> LibraryID; typedef std::vector<LibraryID > LinkLibraryVectorType; const LinkLibraryVectorType &GetOriginalLinkLibraries() const {return this->OriginalLinkLibraries;} - /** Compute the link type to use for the given configuration. */ - LinkLibraryType ComputeLinkType(const std::string& config) const; - /** * Clear the dependency information recorded for this target, if any. */ void ClearDependencyInformation(cmMakefile& mf, const std::string& target); - // Check to see if a library is a framework and treat it different on Mac - bool NameResolvesToFramework(const std::string& libname) const; void AddLinkLibrary(cmMakefile& mf, const std::string& target, const std::string& lib, - LinkLibraryType llt); + cmTargetLinkLibraryType llt); enum TLLSignature { KeywordTLLSignature, PlainTLLSignature @@ -211,12 +173,8 @@ public: void AddUtility(const std::string& u, cmMakefile *makefile = 0); ///! Get the utilities used by this target std::set<std::string>const& GetUtilities() const { return this->Utilities; } - std::set<cmLinkItem>const& GetUtilityItems() const; cmListFileBacktrace const* GetUtilityBacktrace(const std::string& u) const; - /** Finalize the target at the end of the Configure step. */ - void FinishConfigure(); - ///! Set/Get a property of this target file void SetProperty(const std::string& prop, const char *value); void AppendProperty(const std::string& prop, const char* value, @@ -227,70 +185,8 @@ public: void CheckProperty(const std::string& prop, cmMakefile* context) const; bool IsImported() const {return this->IsImportedTarget;} - - void GetObjectLibrariesCMP0026(std::vector<cmTarget*>& objlibs) const; - - cmLinkImplementationLibraries const* - GetLinkImplementationLibraries(const std::string& config) const; - - void ComputeLinkImplementationLibraries(const std::string& config, - cmOptionalLinkImplementation& impl, - cmTarget const* head) const; - - cmOptionalLinkImplementation& - GetLinkImplMap(std::string const& config) const; - - cmTarget const* FindTargetToLink(std::string const& name) const; - - /** Strip off leading and trailing whitespace from an item named in - the link dependencies of this target. */ - std::string CheckCMP0004(std::string const& item) const; - - /** Get the directory in which this target will be built. If the - configuration name is given then the generator will add its - subdirectory for that configuration. Otherwise just the canonical - output directory is given. */ - std::string GetDirectory(const std::string& config = "", - bool implib = false) const; - - /** Get the directory in which this targets .pdb files will be placed. - If the configuration name is given then the generator will add its - subdirectory for that configuration. Otherwise just the canonical - pdb output directory is given. */ - std::string GetPDBDirectory(const std::string& config) const; - - const char* ImportedGetLocation(const std::string& config) const; - - /** Get the target major and minor version numbers interpreted from - the VERSION property. Version 0 is returned if the property is - not set or cannot be parsed. */ - void GetTargetVersion(int& major, int& minor) const; - - /** Get the target major, minor, and patch version numbers - interpreted from the VERSION or SOVERSION property. Version 0 - is returned if the property is not set or cannot be parsed. */ - void - GetTargetVersion(bool soversion, int& major, int& minor, int& patch) const; - - /** Whether this library has \@rpath and platform supports it. */ - bool HasMacOSXRpathInstallNameDir(const std::string& config) const; - - /** Whether this library defaults to \@rpath. */ - bool MacOSXRpathInstallNameDirDefault() const; - - /** Test for special case of a third-party shared library that has - no soname at all. */ - bool IsImportedSharedLibWithoutSOName(const std::string& config) const; - - /** Does this target have a GNU implib to convert to MS format? */ - bool HasImplibGNUtoMS() const; - - /** Convert the given GNU import library name (.dll.a) to a name with a new - extension (.lib or ${CMAKE_IMPORT_LIBRARY_SUFFIX}). */ - bool GetImplibGNUtoMS(std::string const& gnuName, std::string& out, - const char* newExt = 0) const; - - bool HaveInstallTreeRPATH() const; + bool IsImportedGloballyVisible() const + { return this->ImportedGloballyVisible; } // Get the properties cmPropertyMap &GetProperties() const { return this->Properties; } @@ -300,53 +196,20 @@ public: const char** imp, std::string& suffix) const; - /** Get the macro to define when building sources in this target. - If no macro should be defined null is returned. */ - const char* GetExportMacro() const; - /** Return whether this target is an executable with symbol exports enabled. */ bool IsExecutableWithExports() const; - /** Return whether this target may be used to link another target. */ - bool IsLinkable() const; - - /** Return whether or not the target is for a DLL platform. */ - bool IsDLLPlatform() const { return this->DLLPlatform; } - - /** Return whether or not the target has a DLL import library. */ - bool HasImportLibrary() const; - /** Return whether this target is a shared library Framework on Apple. */ bool IsFrameworkOnApple() const; - /** Return whether this target is a CFBundle (plugin) on Apple. */ - bool IsCFBundleOnApple() const; - - /** Return whether this target is a XCTest on Apple. */ - bool IsXCTestOnApple() const; - /** Return whether this target is an executable Bundle on Apple. */ bool IsAppBundleOnApple() const; - /** Return the framework version string. Undefined if - IsFrameworkOnApple returns false. */ - std::string GetFrameworkVersion() const; - /** Get a backtrace from the creation of the target. */ cmListFileBacktrace const& GetBacktrace() const; - /** Get a build-tree directory in which to place target support files. */ - std::string GetSupportDirectory() const; - - /** Return whether this target uses the default value for its output - directory. */ - bool UsesDefaultOutputDir(const std::string& config, bool implib) const; - - /** @return whether this target have a well defined output file name. */ - bool HaveWellDefinedOutputFiles() const; - void InsertInclude(std::string const& entry, cmListFileBacktrace const& bt, bool before = false); @@ -358,24 +221,13 @@ public: void AppendBuildInterfaceIncludes(); - bool IsNullImpliedByLinkLibraries(const std::string &p) const; - std::string GetDebugGeneratorExpressions(const std::string &value, - cmTarget::LinkLibraryType llt) const; + cmTargetLinkLibraryType llt) const; void AddSystemIncludeDirectories(const std::set<std::string> &incs); std::set<std::string> const & GetSystemIncludeDirectories() const { return this->SystemIncludeDirectories; } - bool LinkLanguagePropagatesToDependents() const - { return this->TargetTypeValue == STATIC_LIBRARY; } - - std::map<std::string, std::string> const& - GetMaxLanguageStandards() const - { - return this->MaxLanguageStandards; - } - cmStringRange GetIncludeDirectoriesEntries() const; cmBacktraceRange GetIncludeDirectoriesBacktraces() const; @@ -388,11 +240,22 @@ public: cmStringRange GetCompileDefinitionsEntries() const; cmBacktraceRange GetCompileDefinitionsBacktraces() const; + cmStringRange GetSourceEntries() const; + cmBacktraceRange GetSourceBacktraces() const; + cmStringRange GetLinkImplementationEntries() const; + cmBacktraceRange GetLinkImplementationBacktraces() const; + #if defined(_WIN32) && !defined(__CYGWIN__) const LinkLibraryVectorType &GetLinkLibrariesForVS6() const { return this->LinkLibrariesForVS6;} + + void AnalyzeLibDependenciesForVS6( const cmMakefile& mf ); #endif + struct StrictTargetComparison { + bool operator()(cmTarget const* t1, cmTarget const* t2) const; + }; + private: bool HandleLocationPropertyPolicy(cmMakefile* context) const; @@ -445,8 +308,6 @@ private: void GatherDependenciesForVS6( const cmMakefile& mf, const LibraryID& lib, DependencyMap& dep_map); - - void AnalyzeLibDependenciesForVS6( const cmMakefile& mf ); #endif const char* GetSuffixVariableInternal(bool implib) const; @@ -457,31 +318,19 @@ private: void SetPropertyDefault(const std::string& property, const char* default_value); - // Returns ARCHIVE, LIBRARY, or RUNTIME based on platform and type. - const char* GetOutputTargetType(bool implib) const; - - std::string GetFullNameImported(const std::string& config, - bool implib) const; - std::string ImportedGetFullPath(const std::string& config, bool implib) const; - - void GetSourceFiles(std::vector<std::string> &files, - const std::string& config) const; private: mutable cmPropertyMap Properties; std::set<std::string> SystemIncludeDirectories; std::set<std::string> LinkDirectoriesEmmitted; std::set<std::string> Utilities; - mutable std::set<std::string> LinkImplicitNullProperties; std::map<std::string, cmListFileBacktrace> UtilityBacktraces; - mutable std::map<std::string, std::string> MaxLanguageStandards; cmPolicies::PolicyMap PolicyMap; std::string Name; std::string InstallPath; std::string RuntimeInstallPath; - mutable std::string ExportMacro; std::vector<std::string> LinkDirectories; std::vector<cmCustomCommand> PreBuildCommands; std::vector<cmCustomCommand> PreLinkCommands; @@ -494,69 +343,29 @@ private: #endif cmMakefile* Makefile; cmTargetInternalPointer Internal; - TargetType TargetTypeValue; + cmState::TargetType TargetTypeValue; bool HaveInstallRule; bool RecordDependencies; bool DLLPlatform; bool IsAndroid; - bool IsApple; bool IsImportedTarget; + bool ImportedGloballyVisible; bool BuildInterfaceIncludesAppended; - mutable bool DebugSourcesDone; - mutable bool LinkImplementationLanguageIsContextDependent; #if defined(_WIN32) && !defined(__CYGWIN__) bool LinkLibrariesForVS6Analyzed; #endif - // Cache target output paths for each configuration. - struct OutputInfo; - OutputInfo const* GetOutputInfo(const std::string& config) const; - bool - ComputeOutputDir(const std::string& config, - bool implib, std::string& out) const; - bool ComputePDBOutputDir(const std::string& kind, const std::string& config, - std::string& out) const; - - // Cache import information from properties for each configuration. - struct ImportInfo - { - ImportInfo(): NoSOName(false), Multiplicity(0) {} - bool NoSOName; - int Multiplicity; - std::string Location; - std::string SOName; - std::string ImportLibrary; - std::string Languages; - std::string Libraries; - std::string LibrariesProp; - std::string SharedDeps; - }; - - ImportInfo const* GetImportInfo(const std::string& config) const; - void ComputeImportInfo(std::string const& desired_config, - ImportInfo& info) const; - - cmLinkImplementationLibraries const* - GetLinkImplementationLibrariesInternal(const std::string& config, - cmTarget const* head) const; - std::string ProcessSourceItemCMP0049(const std::string& s); - void ClearLinkMaps(); - - void MaybeInvalidatePropertyCache(const std::string& prop); + /** Return whether or not the target has a DLL import library. */ + bool HasImportLibrary() const; // Internal representation details. friend class cmTargetInternals; friend class cmGeneratorTarget; friend class cmTargetTraceDependencies; - void ComputeVersionedName(std::string& vName, - std::string const& prefix, - std::string const& base, - std::string const& suffix, - std::string const& name, - const char* version) const; + cmListFileBacktrace Backtrace; }; #ifdef CMAKE_BUILD_WITH_CMAKE diff --git a/Source/cmTargetExport.h b/Source/cmTargetExport.h index 7665888..2781337 100644 --- a/Source/cmTargetExport.h +++ b/Source/cmTargetExport.h @@ -14,7 +14,7 @@ #include "cmStandardIncludes.h" -class cmTarget; +class cmGeneratorTarget; class cmInstallTargetGenerator; class cmInstallFilesGenerator; @@ -25,7 +25,8 @@ class cmInstallFilesGenerator; class cmTargetExport { public: - cmTarget* Target; ///< The target + std::string TargetName; + cmGeneratorTarget* Target; ///@name Generators ///@{ diff --git a/Source/cmTargetLinkLibrariesCommand.cxx b/Source/cmTargetLinkLibrariesCommand.cxx index b57b921..435346a 100644 --- a/Source/cmTargetLinkLibrariesCommand.cxx +++ b/Source/cmTargetLinkLibrariesCommand.cxx @@ -88,7 +88,7 @@ bool cmTargetLinkLibrariesCommand return true; } - if(this->Target->GetType() == cmTarget::OBJECT_LIBRARY) + if(this->Target->GetType() == cmState::OBJECT_LIBRARY) { std::ostringstream e; e << "Object library target \"" << args[0] << "\" " @@ -98,7 +98,7 @@ bool cmTargetLinkLibrariesCommand return true; } - if (this->Target->GetType() == cmTarget::UTILITY) + if (this->Target->GetType() == cmState::UTILITY) { std::ostringstream e; const char *modal = 0; @@ -136,7 +136,7 @@ bool cmTargetLinkLibrariesCommand } // Keep track of link configuration specifiers. - cmTarget::LinkLibraryType llt = cmTarget::GENERAL; + cmTargetLinkLibraryType llt = GENERAL_LibraryType; bool haveLLT = false; // Start with primary linking and switch to link interface @@ -242,27 +242,27 @@ bool cmTargetLinkLibrariesCommand { if(haveLLT) { - this->LinkLibraryTypeSpecifierWarning(llt, cmTarget::DEBUG); + this->LinkLibraryTypeSpecifierWarning(llt, DEBUG_LibraryType); } - llt = cmTarget::DEBUG; + llt = DEBUG_LibraryType; haveLLT = true; } else if(args[i] == "optimized") { if(haveLLT) { - this->LinkLibraryTypeSpecifierWarning(llt, cmTarget::OPTIMIZED); + this->LinkLibraryTypeSpecifierWarning(llt, OPTIMIZED_LibraryType); } - llt = cmTarget::OPTIMIZED; + llt = OPTIMIZED_LibraryType; haveLLT = true; } else if(args[i] == "general") { if(haveLLT) { - this->LinkLibraryTypeSpecifierWarning(llt, cmTarget::GENERAL); + this->LinkLibraryTypeSpecifierWarning(llt, GENERAL_LibraryType); } - llt = cmTarget::GENERAL; + llt = GENERAL_LibraryType; haveLLT = true; } else if(haveLLT) @@ -282,7 +282,7 @@ bool cmTargetLinkLibrariesCommand // specifed that a library is both debug and optimized. (this check is // only there for backwards compatibility when mixing projects built // with old versions of CMake and new) - llt = cmTarget::GENERAL; + llt = GENERAL_LibraryType; std::string linkType = args[0]; linkType += "_LINK_TYPE"; const char* linkTypeString = @@ -291,11 +291,11 @@ bool cmTargetLinkLibrariesCommand { if(strcmp(linkTypeString, "debug") == 0) { - llt = cmTarget::DEBUG; + llt = DEBUG_LibraryType; } if(strcmp(linkTypeString, "optimized") == 0) { - llt = cmTarget::OPTIMIZED; + llt = OPTIMIZED_LibraryType; } } if (!this->HandleLibrary(args[i], llt)) @@ -350,9 +350,9 @@ cmTargetLinkLibrariesCommand //---------------------------------------------------------------------------- bool cmTargetLinkLibrariesCommand::HandleLibrary(const std::string& lib, - cmTarget::LinkLibraryType llt) + cmTargetLinkLibraryType llt) { - if(this->Target->GetType() == cmTarget::INTERFACE_LIBRARY + if(this->Target->GetType() == cmState::INTERFACE_LIBRARY && this->CurrentProcessingState != ProcessingKeywordLinkInterface) { this->Makefile->IssueMessage(cmake::FATAL_ERROR, @@ -428,7 +428,7 @@ cmTargetLinkLibrariesCommand::HandleLibrary(const std::string& lib, else if(this->CurrentProcessingState != ProcessingKeywordPublicInterface && this->CurrentProcessingState != ProcessingPlainPublicInterface) { - if (this->Target->GetType() == cmTarget::STATIC_LIBRARY) + if (this->Target->GetType() == cmState::STATIC_LIBRARY) { std::string configLib = this->Target ->GetDebugGeneratorExpressions(lib, llt); @@ -458,7 +458,7 @@ cmTargetLinkLibrariesCommand::HandleLibrary(const std::string& lib, return true; } - if (this->Target->GetType() == cmTarget::INTERFACE_LIBRARY) + if (this->Target->GetType() == cmState::INTERFACE_LIBRARY) { return true; } @@ -469,7 +469,7 @@ cmTargetLinkLibrariesCommand::HandleLibrary(const std::string& lib, std::string prop; // Include this library in the link interface for the target. - if(llt == cmTarget::DEBUG || llt == cmTarget::GENERAL) + if(llt == DEBUG_LibraryType || llt == GENERAL_LibraryType) { // Put in the DEBUG configuration interfaces. for(std::vector<std::string>::const_iterator i = debugConfigs.begin(); @@ -480,7 +480,7 @@ cmTargetLinkLibrariesCommand::HandleLibrary(const std::string& lib, this->Target->AppendProperty(prop, lib.c_str()); } } - if(llt == cmTarget::OPTIMIZED || llt == cmTarget::GENERAL) + if(llt == OPTIMIZED_LibraryType || llt == GENERAL_LibraryType) { // Put in the non-DEBUG configuration interfaces. this->Target->AppendProperty("LINK_INTERFACE_LIBRARIES", lib.c_str()); diff --git a/Source/cmTargetLinkLibrariesCommand.h b/Source/cmTargetLinkLibrariesCommand.h index 47dd8bd..f061e6d 100644 --- a/Source/cmTargetLinkLibrariesCommand.h +++ b/Source/cmTargetLinkLibrariesCommand.h @@ -62,7 +62,7 @@ private: ProcessingState CurrentProcessingState; - bool HandleLibrary(const std::string& lib, cmTarget::LinkLibraryType llt); + bool HandleLibrary(const std::string& lib, cmTargetLinkLibraryType llt); }; diff --git a/Source/cmTargetPropCommandBase.cxx b/Source/cmTargetPropCommandBase.cxx index 4696de4..bfc19a4 100644 --- a/Source/cmTargetPropCommandBase.cxx +++ b/Source/cmTargetPropCommandBase.cxx @@ -44,12 +44,12 @@ bool cmTargetPropCommandBase this->HandleMissingTarget(args[0]); return false; } - if ((this->Target->GetType() != cmTarget::SHARED_LIBRARY) - && (this->Target->GetType() != cmTarget::STATIC_LIBRARY) - && (this->Target->GetType() != cmTarget::OBJECT_LIBRARY) - && (this->Target->GetType() != cmTarget::MODULE_LIBRARY) - && (this->Target->GetType() != cmTarget::INTERFACE_LIBRARY) - && (this->Target->GetType() != cmTarget::EXECUTABLE)) + if ((this->Target->GetType() != cmState::SHARED_LIBRARY) + && (this->Target->GetType() != cmState::STATIC_LIBRARY) + && (this->Target->GetType() != cmState::OBJECT_LIBRARY) + && (this->Target->GetType() != cmState::MODULE_LIBRARY) + && (this->Target->GetType() != cmState::INTERFACE_LIBRARY) + && (this->Target->GetType() != cmState::EXECUTABLE)) { this->SetError("called with non-compilable target type"); return false; @@ -114,7 +114,7 @@ bool cmTargetPropCommandBase return false; } - if (this->Target->GetType() == cmTarget::INTERFACE_LIBRARY + if (this->Target->GetType() == cmState::INTERFACE_LIBRARY && scope != "INTERFACE") { this->SetError("may only be set INTERFACE properties on INTERFACE " diff --git a/Source/cmTestGenerator.cxx b/Source/cmTestGenerator.cxx index 9d85f5a..b411f15 100644 --- a/Source/cmTestGenerator.cxx +++ b/Source/cmTestGenerator.cxx @@ -13,10 +13,8 @@ #include "cmGeneratorExpression.h" #include "cmOutputConverter.h" -#include "cmMakefile.h" #include "cmLocalGenerator.h" #include "cmSystemTools.h" -#include "cmTarget.h" #include "cmTest.h" //---------------------------------------------------------------------------- @@ -89,8 +87,8 @@ void cmTestGenerator::GenerateScriptForConfig(std::ostream& os, // be translated. std::string exe = command[0]; cmGeneratorTarget* target = - this->LG->GetMakefile()->FindGeneratorTargetToUse(exe); - if(target && target->GetType() == cmTarget::EXECUTABLE) + this->LG->FindGeneratorTargetToUse(exe); + if(target && target->GetType() == cmState::EXECUTABLE) { // Use the target file on disk. exe = target->GetFullPath(config); @@ -117,7 +115,7 @@ void cmTestGenerator::GenerateScriptForConfig(std::ostream& os, else { // Use the command name given. - exe = ge.Parse(exe.c_str())->Evaluate(this->LG->GetMakefile(), config); + exe = ge.Parse(exe.c_str())->Evaluate(this->LG, config); cmSystemTools::ConvertToUnixSlashes(exe); } @@ -128,7 +126,7 @@ void cmTestGenerator::GenerateScriptForConfig(std::ostream& os, { os << " " << cmOutputConverter::EscapeForCMake( ge.Parse(*ci)->Evaluate( - this->LG->GetMakefile(), config)); + this->LG, config)); } // Finish the test command. @@ -145,7 +143,7 @@ void cmTestGenerator::GenerateScriptForConfig(std::ostream& os, { os << " " << i->first << " " << cmOutputConverter::EscapeForCMake( - ge.Parse(i->second.GetValue())->Evaluate(this->LG->GetMakefile(), + ge.Parse(i->second.GetValue())->Evaluate(this->LG, config)); } os << ")" << std::endl; diff --git a/Source/cmUtilitySourceCommand.cxx b/Source/cmUtilitySourceCommand.cxx index 486328f..3f1e333 100644 --- a/Source/cmUtilitySourceCommand.cxx +++ b/Source/cmUtilitySourceCommand.cxx @@ -11,8 +11,6 @@ ============================================================================*/ #include "cmUtilitySourceCommand.h" -#include "cmCacheManager.h" - // cmUtilitySourceCommand bool cmUtilitySourceCommand ::InitialPass(std::vector<std::string> const& args, cmExecutionStatus &) @@ -54,13 +52,13 @@ bool cmUtilitySourceCommand } else { - cmCacheManager *manager = - this->Makefile->GetCMakeInstance()->GetCacheManager(); + cmState *state = + this->Makefile->GetState(); haveCacheValue = (cacheValue && (strstr(cacheValue, "(IntDir)") == 0 || (intDir && strcmp(intDir, "$(IntDir)") == 0)) && - (manager->GetCacheMajorVersion() != 0 && - manager->GetCacheMinorVersion() != 0 )); + (state->GetCacheMajorVersion() != 0 && + state->GetCacheMinorVersion() != 0 )); } if(haveCacheValue) diff --git a/Source/cmVisualStudio10TargetGenerator.cxx b/Source/cmVisualStudio10TargetGenerator.cxx index 1de2847..6e1fb5b 100644 --- a/Source/cmVisualStudio10TargetGenerator.cxx +++ b/Source/cmVisualStudio10TargetGenerator.cxx @@ -13,7 +13,6 @@ #include "cmVisualStudio10TargetGenerator.h" #include "cmGlobalVisualStudio10Generator.h" #include "cmGeneratorTarget.h" -#include "cmTarget.h" #include "cmComputeLinkInformation.h" #include "cmGeneratedFileStream.h" #include "cmMakefile.h" @@ -167,18 +166,17 @@ static std::string cmVS10EscapeComment(std::string comment) } cmVisualStudio10TargetGenerator:: -cmVisualStudio10TargetGenerator(cmTarget* target, +cmVisualStudio10TargetGenerator(cmGeneratorTarget* target, cmGlobalVisualStudio10Generator* gg) { this->GlobalGenerator = gg; - this->Target = target; - this->GeneratorTarget = gg->GetGeneratorTarget(target); - this->Makefile = target->GetMakefile(); + this->GeneratorTarget = target; + this->Makefile = target->Target->GetMakefile(); this->Makefile->GetConfigurations(this->Configurations); this->LocalGenerator = (cmLocalVisualStudio7Generator*) this->GeneratorTarget->GetLocalGenerator(); - this->Name = this->Target->GetName(); + this->Name = this->GeneratorTarget->GetName(); this->GUID = this->GlobalGenerator->GetGUID(this->Name.c_str()); this->Platform = gg->GetPlatformName(); this->NsightTegra = gg->IsNsightTegra(); @@ -195,8 +193,8 @@ cmVisualStudio10TargetGenerator(cmTarget* target, this->BuildFileStream = 0; this->IsMissingFiles = false; this->DefaultArtifactDir = - this->Makefile->GetCurrentBinaryDirectory() + std::string("/") + - this->LocalGenerator->GetTargetDirectory(*this->Target); + this->LocalGenerator->GetCurrentBinaryDirectory() + std::string("/") + + this->LocalGenerator->GetTargetDirectory(this->GeneratorTarget); } cmVisualStudio10TargetGenerator::~cmVisualStudio10TargetGenerator() @@ -269,16 +267,17 @@ void cmVisualStudio10TargetGenerator::WriteString(const char* line, void cmVisualStudio10TargetGenerator::Generate() { // do not generate external ms projects - if(this->Target->GetType() == cmTarget::INTERFACE_LIBRARY - || this->Target->GetProperty("EXTERNAL_MSPROJECT")) + if(this->GeneratorTarget->GetType() == cmState::INTERFACE_LIBRARY + || this->GeneratorTarget->GetProperty("EXTERNAL_MSPROJECT")) { return; } // Tell the global generator the name of the project file - this->Target->SetProperty("GENERATOR_FILE_NAME",this->Name.c_str()); - this->Target->SetProperty("GENERATOR_FILE_NAME_EXT", + this->GeneratorTarget->Target + ->SetProperty("GENERATOR_FILE_NAME",this->Name.c_str()); + this->GeneratorTarget->Target->SetProperty("GENERATOR_FILE_NAME_EXT", ".vcxproj"); - if(this->Target->GetType() <= cmTarget::OBJECT_LIBRARY) + if(this->GeneratorTarget->GetType() <= cmState::OBJECT_LIBRARY) { if(!this->ComputeClOptions()) { @@ -297,8 +296,7 @@ void cmVisualStudio10TargetGenerator::Generate() return; } } - cmMakefile* mf = this->Target->GetMakefile(); - std::string path = mf->GetCurrentBinaryDirectory(); + std::string path = this->LocalGenerator->GetCurrentBinaryDirectory(); path += "/"; path += this->Name; path += ".vcxproj"; @@ -361,14 +359,15 @@ void cmVisualStudio10TargetGenerator::Generate() this->WriteString("<ProjectGUID>", 2); (*this->BuildFileStream) << "{" << this->GUID << "}</ProjectGUID>\n"; - if(this->MSTools && this->Target->GetType() <= cmTarget::GLOBAL_TARGET) + if(this->MSTools + && this->GeneratorTarget->GetType() <= cmState::GLOBAL_TARGET) { this->WriteApplicationTypeSettings(); this->VerifyNecessaryFiles(); } const char* vsProjectTypes = - this->Target->GetProperty("VS_GLOBAL_PROJECT_TYPES"); + this->GeneratorTarget->GetProperty("VS_GLOBAL_PROJECT_TYPES"); if(vsProjectTypes) { this->WriteString("<ProjectTypes>", 2); @@ -376,9 +375,12 @@ void cmVisualStudio10TargetGenerator::Generate() "</ProjectTypes>\n"; } - const char* vsProjectName = this->Target->GetProperty("VS_SCC_PROJECTNAME"); - const char* vsLocalPath = this->Target->GetProperty("VS_SCC_LOCALPATH"); - const char* vsProvider = this->Target->GetProperty("VS_SCC_PROVIDER"); + const char* vsProjectName = + this->GeneratorTarget->GetProperty("VS_SCC_PROJECTNAME"); + const char* vsLocalPath = + this->GeneratorTarget->GetProperty("VS_SCC_LOCALPATH"); + const char* vsProvider = + this->GeneratorTarget->GetProperty("VS_SCC_PROVIDER"); if( vsProjectName && vsLocalPath && vsProvider ) { @@ -392,7 +394,8 @@ void cmVisualStudio10TargetGenerator::Generate() (*this->BuildFileStream) << cmVS10EscapeXML(vsProvider) << "</SccProvider>\n"; - const char* vsAuxPath = this->Target->GetProperty("VS_SCC_AUXPATH"); + const char* vsAuxPath = + this->GeneratorTarget->GetProperty("VS_SCC_AUXPATH"); if( vsAuxPath ) { this->WriteString("<SccAuxPath>", 2); @@ -401,13 +404,13 @@ void cmVisualStudio10TargetGenerator::Generate() } } - if(this->Target->GetPropertyAsBool("VS_WINRT_COMPONENT")) + if(this->GeneratorTarget->GetPropertyAsBool("VS_WINRT_COMPONENT")) { this->WriteString("<WinMDAssembly>true</WinMDAssembly>\n", 2); } const char* vsGlobalKeyword = - this->Target->GetProperty("VS_GLOBAL_KEYWORD"); + this->GeneratorTarget->GetProperty("VS_GLOBAL_KEYWORD"); if(!vsGlobalKeyword) { this->WriteString("<Keyword>Win32Proj</Keyword>\n", 2); @@ -420,7 +423,7 @@ void cmVisualStudio10TargetGenerator::Generate() } const char* vsGlobalRootNamespace = - this->Target->GetProperty("VS_GLOBAL_ROOTNAMESPACE"); + this->GeneratorTarget->GetProperty("VS_GLOBAL_ROOTNAMESPACE"); if(vsGlobalRootNamespace) { this->WriteString("<RootNamespace>", 2); @@ -431,14 +434,14 @@ void cmVisualStudio10TargetGenerator::Generate() this->WriteString("<Platform>", 2); (*this->BuildFileStream) << cmVS10EscapeXML(this->Platform) << "</Platform>\n"; - const char* projLabel = this->Target->GetProperty("PROJECT_LABEL"); + const char* projLabel = this->GeneratorTarget->GetProperty("PROJECT_LABEL"); if(!projLabel) { projLabel = this->Name.c_str(); } this->WriteString("<ProjectName>", 2); (*this->BuildFileStream) << cmVS10EscapeXML(projLabel) << "</ProjectName>\n"; - if(const char* targetFrameworkVersion = this->Target->GetProperty( + if(const char* targetFrameworkVersion = this->GeneratorTarget->GetProperty( "VS_DOTNET_TARGET_FRAMEWORK_VERSION")) { this->WriteString("<TargetFrameworkVersion>", 2); @@ -497,7 +500,7 @@ void cmVisualStudio10TargetGenerator::WriteDotNetReferences() { std::vector<std::string> references; if(const char* vsDotNetReferences = - this->Target->GetProperty("VS_DOTNET_REFERENCES")) + this->GeneratorTarget->GetProperty("VS_DOTNET_REFERENCES")) { cmSystemTools::ExpandListArgument(vsDotNetReferences, references); } @@ -543,7 +546,7 @@ void cmVisualStudio10TargetGenerator::WriteEmbeddedResourceGroup() i != this->Configurations.end(); ++i) { this->WritePlatformConfigTag("LogicalName", i->c_str(), 3); - if(this->Target->GetProperty("VS_GLOBAL_ROOTNAMESPACE")) + if(this->GeneratorTarget->GetProperty("VS_GLOBAL_ROOTNAMESPACE")) { (*this->BuildFileStream ) << "$(RootNamespace)."; } @@ -610,7 +613,7 @@ void cmVisualStudio10TargetGenerator::WriteWinRTReferences() { std::vector<std::string> references; if(const char* vsWinRTReferences = - this->Target->GetProperty("VS_WINRT_REFERENCES")) + this->GeneratorTarget->GetProperty("VS_WINRT_REFERENCES")) { cmSystemTools::ExpandListArgument(vsWinRTReferences, references); } @@ -667,19 +670,19 @@ void cmVisualStudio10TargetGenerator::WriteProjectConfigurationValues() i->c_str(), 1, " Label=\"Configuration\"", "\n"); std::string configType = "<ConfigurationType>"; - switch(this->Target->GetType()) + switch(this->GeneratorTarget->GetType()) { - case cmTarget::SHARED_LIBRARY: - case cmTarget::MODULE_LIBRARY: + case cmState::SHARED_LIBRARY: + case cmState::MODULE_LIBRARY: configType += "DynamicLibrary"; break; - case cmTarget::OBJECT_LIBRARY: - case cmTarget::STATIC_LIBRARY: + case cmState::OBJECT_LIBRARY: + case cmState::STATIC_LIBRARY: configType += "StaticLibrary"; break; - case cmTarget::EXECUTABLE: + case cmState::EXECUTABLE: if(this->NsightTegra && - !this->Target->GetPropertyAsBool("ANDROID_GUI")) + !this->GeneratorTarget->GetPropertyAsBool("ANDROID_GUI")) { // Android executables are .so too. configType += "DynamicLibrary"; @@ -689,8 +692,8 @@ void cmVisualStudio10TargetGenerator::WriteProjectConfigurationValues() configType += "Application"; } break; - case cmTarget::UTILITY: - case cmTarget::GLOBAL_TARGET: + case cmState::UTILITY: + case cmState::GLOBAL_TARGET: if(this->NsightTegra) { // Tegra-Android platform does not understand "Utility". @@ -701,8 +704,8 @@ void cmVisualStudio10TargetGenerator::WriteProjectConfigurationValues() configType += "Utility"; } break; - case cmTarget::UNKNOWN_LIBRARY: - case cmTarget::INTERFACE_LIBRARY: + case cmState::UNKNOWN_LIBRARY: + case cmState::INTERFACE_LIBRARY: break; } configType += "</ConfigurationType>\n"; @@ -728,7 +731,8 @@ void cmVisualStudio10TargetGenerator cmGlobalVisualStudio10Generator* gg = static_cast<cmGlobalVisualStudio10Generator*>(this->GlobalGenerator); const char* mfcFlag = - this->Target->GetMakefile()->GetDefinition("CMAKE_MFC_FLAG"); + this->GeneratorTarget-> + Target->GetMakefile()->GetDefinition("CMAKE_MFC_FLAG"); std::string mfcFlagValue = mfcFlag ? mfcFlag : "0"; std::string useOfMfcValue = "false"; @@ -744,16 +748,16 @@ void cmVisualStudio10TargetGenerator mfcLine += useOfMfcValue + "</UseOfMfc>\n"; this->WriteString(mfcLine.c_str(), 2); - if((this->Target->GetType() <= cmTarget::OBJECT_LIBRARY && + if((this->GeneratorTarget->GetType() <= cmState::OBJECT_LIBRARY && this->ClOptions[config]->UsingUnicode()) || - this->Target->GetPropertyAsBool("VS_WINRT_COMPONENT") || + this->GeneratorTarget->GetPropertyAsBool("VS_WINRT_COMPONENT") || this->GlobalGenerator->TargetsWindowsPhone() || this->GlobalGenerator->TargetsWindowsStore() || - this->Target->GetPropertyAsBool("VS_WINRT_EXTENSIONS")) + this->GeneratorTarget->GetPropertyAsBool("VS_WINRT_EXTENSIONS")) { this->WriteString("<CharacterSet>Unicode</CharacterSet>\n", 2); } - else if (this->Target->GetType() <= cmTarget::MODULE_LIBRARY && + else if (this->GeneratorTarget->GetType() <= cmState::MODULE_LIBRARY && this->ClOptions[config]->UsingSBCS()) { this->WriteString("<CharacterSet>NotSet</CharacterSet>\n", 2); @@ -769,8 +773,8 @@ void cmVisualStudio10TargetGenerator pts += "</PlatformToolset>\n"; this->WriteString(pts.c_str(), 2); } - if(this->Target->GetPropertyAsBool("VS_WINRT_COMPONENT") || - this->Target->GetPropertyAsBool("VS_WINRT_EXTENSIONS")) + if(this->GeneratorTarget->GetPropertyAsBool("VS_WINRT_COMPONENT") || + this->GeneratorTarget->GetPropertyAsBool("VS_WINRT_EXTENSIONS")) { this->WriteString("<WindowsAppContainer>true" "</WindowsAppContainer>\n", 2); @@ -788,27 +792,29 @@ void cmVisualStudio10TargetGenerator ntv += toolset? toolset : "Default"; ntv += "</NdkToolchainVersion>\n"; this->WriteString(ntv.c_str(), 2); - if(const char* minApi = this->Target->GetProperty("ANDROID_API_MIN")) + if(const char* minApi = + this->GeneratorTarget->GetProperty("ANDROID_API_MIN")) { this->WriteString("<AndroidMinAPI>", 2); (*this->BuildFileStream ) << "android-" << cmVS10EscapeXML(minApi) << "</AndroidMinAPI>\n"; } - if(const char* api = this->Target->GetProperty("ANDROID_API")) + if(const char* api = this->GeneratorTarget->GetProperty("ANDROID_API")) { this->WriteString("<AndroidTargetAPI>", 2); (*this->BuildFileStream ) << "android-" << cmVS10EscapeXML(api) << "</AndroidTargetAPI>\n"; } - if(const char* cpuArch = this->Target->GetProperty("ANDROID_ARCH")) + if(const char* cpuArch = this->GeneratorTarget->GetProperty("ANDROID_ARCH")) { this->WriteString("<AndroidArch>", 2); (*this->BuildFileStream) << cmVS10EscapeXML(cpuArch) << "</AndroidArch>\n"; } - if(const char* stlType = this->Target->GetProperty("ANDROID_STL_TYPE")) + if(const char* stlType = + this->GeneratorTarget->GetProperty("ANDROID_STL_TYPE")) { this->WriteString("<AndroidStlType>", 2); (*this->BuildFileStream) << cmVS10EscapeXML(stlType) << @@ -951,7 +957,7 @@ cmVisualStudio10TargetGenerator::ConvertPath(std::string const& path, { return forceRelative ? cmSystemTools::RelativePath( - this->Makefile->GetCurrentBinaryDirectory(), path.c_str()) + this->LocalGenerator->GetCurrentBinaryDirectory(), path.c_str()) : path.c_str(); } @@ -990,7 +996,7 @@ void cmVisualStudio10TargetGenerator::WriteGroups() this->AddMissingSourceGroups(groupsUsed, sourceGroups); // Write out group file - std::string path = this->Makefile->GetCurrentBinaryDirectory(); + std::string path = this->LocalGenerator->GetCurrentBinaryDirectory(); path += "/"; path += this->Name; path += ".vcxproj.filters"; @@ -1375,7 +1381,7 @@ void cmVisualStudio10TargetGenerator::WriteExtraSource(cmSourceFile const* sf) } for(size_t i = 0; i != this->Configurations.size(); ++i) { - if(0 == strcmp(cge->Evaluate(this->Makefile, + if(0 == strcmp(cge->Evaluate(this->LocalGenerator, this->Configurations[i]), "1")) { this->WriteString("<DeploymentContent Condition=\"" @@ -1452,7 +1458,7 @@ void cmVisualStudio10TargetGenerator::WriteSource( std::string sourceRel = this->ConvertPath(sf->GetFullPath(), true); size_t const maxLen = 250; if(sf->GetCustomCommand() || - ((strlen(this->Makefile->GetCurrentBinaryDirectory()) + 1 + + ((strlen(this->LocalGenerator->GetCurrentBinaryDirectory()) + 1 + sourceRel.length()) <= maxLen)) { forceRelative = true; @@ -1460,7 +1466,8 @@ void cmVisualStudio10TargetGenerator::WriteSource( } else { - this->GlobalGenerator->PathTooLong(this->Target, sf, sourceRel); + this->GlobalGenerator->PathTooLong(this->GeneratorTarget, + sf, sourceRel); } } this->ConvertToWindowsSlash(sourceFile); @@ -1485,7 +1492,7 @@ void cmVisualStudio10TargetGenerator::WriteSources( void cmVisualStudio10TargetGenerator::WriteAllSources() { - if(this->Target->GetType() > cmTarget::UTILITY) + if(this->GeneratorTarget->GetType() > cmState::UTILITY) { return; } @@ -1606,6 +1613,12 @@ void cmVisualStudio10TargetGenerator::WriteAllSources() (*this->BuildFileStream ) << cmVS10EscapeXML(obj) << "\" />\n"; } + if (cmSourceFile const* defsrc = + this->GeneratorTarget->GetModuleDefinitionFile("")) + { + this->WriteSource("None", defsrc); + } + if (this->IsMissingFiles) { this->WriteMissingFiles(); @@ -1747,8 +1760,8 @@ bool cmVisualStudio10TargetGenerator::OutputSourceSpecificFlags( void cmVisualStudio10TargetGenerator::WritePathAndIncrementalLinkOptions() { - cmTarget::TargetType ttype = this->Target->GetType(); - if(ttype > cmTarget::GLOBAL_TARGET) + cmState::TargetType ttype = this->GeneratorTarget->GetType(); + if(ttype > cmState::GLOBAL_TARGET) { return; } @@ -1760,7 +1773,7 @@ void cmVisualStudio10TargetGenerator::WritePathAndIncrementalLinkOptions() config = this->Configurations.begin(); config != this->Configurations.end(); ++config) { - if(ttype >= cmTarget::UTILITY) + if(ttype >= cmState::UTILITY) { this->WritePlatformConfigTag("IntDir", config->c_str(), 3); *this->BuildFileStream @@ -1770,21 +1783,21 @@ void cmVisualStudio10TargetGenerator::WritePathAndIncrementalLinkOptions() else { std::string intermediateDir = this->LocalGenerator-> - GetTargetDirectory(*this->Target); + GetTargetDirectory(this->GeneratorTarget); intermediateDir += "/"; intermediateDir += *config; intermediateDir += "/"; std::string outDir; std::string targetNameFull; - if(ttype == cmTarget::OBJECT_LIBRARY) + if(ttype == cmState::OBJECT_LIBRARY) { outDir = intermediateDir; - targetNameFull = this->Target->GetName(); + targetNameFull = this->GeneratorTarget->GetName(); targetNameFull += ".lib"; } else { - outDir = this->Target->GetDirectory(config->c_str()) + "/"; + outDir = this->GeneratorTarget->GetDirectory(config->c_str()) + "/"; targetNameFull = this->GeneratorTarget->GetFullName(config->c_str()); } this->ConvertToWindowsSlash(intermediateDir); @@ -1832,8 +1845,8 @@ OutputLinkIncremental(std::string const& configName) } // static libraries and things greater than modules do not need // to set this option - if(this->Target->GetType() == cmTarget::STATIC_LIBRARY - || this->Target->GetType() > cmTarget::MODULE_LIBRARY) + if(this->GeneratorTarget->GetType() == cmState::STATIC_LIBRARY + || this->GeneratorTarget->GetType() > cmState::MODULE_LIBRARY) { return; } @@ -1913,12 +1926,12 @@ bool cmVisualStudio10TargetGenerator::ComputeClOptions( std::string baseFlagVar = "CMAKE_"; baseFlagVar += linkLanguage; baseFlagVar += "_FLAGS"; - flags = this-> + flags = this->GeneratorTarget-> Target->GetMakefile()->GetRequiredDefinition(baseFlagVar.c_str()); std::string flagVar = baseFlagVar + std::string("_") + cmSystemTools::UpperCase(configName); flags += " "; - flags += this-> + flags += this->GeneratorTarget-> Target->GetMakefile()->GetRequiredDefinition(flagVar.c_str()); } // set the correct language @@ -1930,11 +1943,12 @@ bool cmVisualStudio10TargetGenerator::ComputeClOptions( { clOptions.AddFlag("CompileAs", "CompileAsCpp"); } - this->LocalGenerator->AddCompileOptions(flags, this->Target, + this->LocalGenerator->AddCompileOptions(flags, this->GeneratorTarget, linkLanguage, configName.c_str()); // Get preprocessor definitions for this directory. - std::string defineFlags = this->Target->GetMakefile()->GetDefineFlags(); + std::string defineFlags = + this->GeneratorTarget->Target->GetMakefile()->GetDefineFlags(); if(this->MSTools) { clOptions.FixExceptionHandlingDefault(); @@ -1959,7 +1973,8 @@ bool cmVisualStudio10TargetGenerator::ComputeClOptions( configDefine += configName; configDefine += "\""; clOptions.AddDefine(configDefine); - if(const char* exportMacro = this->Target->GetExportMacro()) + if(const char* exportMacro = + this->GeneratorTarget->GetExportMacro()) { clOptions.AddDefine(exportMacro); } @@ -1967,12 +1982,12 @@ bool cmVisualStudio10TargetGenerator::ComputeClOptions( if (this->MSTools) { // If we have the VS_WINRT_COMPONENT set then force Compile as WinRT. - if (this->Target->GetPropertyAsBool("VS_WINRT_COMPONENT")) + if (this->GeneratorTarget->GetPropertyAsBool("VS_WINRT_COMPONENT")) { clOptions.AddFlag("CompileAsWinRT", "true"); // For WinRT components, add the _WINRT_DLL define to produce a lib - if (this->Target->GetType() == cmTarget::SHARED_LIBRARY || - this->Target->GetType() == cmTarget::MODULE_LIBRARY ) + if (this->GeneratorTarget->GetType() == cmState::SHARED_LIBRARY || + this->GeneratorTarget->GetType() == cmState::MODULE_LIBRARY ) { clOptions.AddDefine("_WINRT_DLL"); } @@ -2016,7 +2031,7 @@ void cmVisualStudio10TargetGenerator::WriteClOptions( if(this->NsightTegra) { if(const char* processMax = - this->Target->GetProperty("ANDROID_PROCESS_MAX")) + this->GeneratorTarget->GetProperty("ANDROID_PROCESS_MAX")) { this->WriteString("<ProcessMax>", 3); *this->BuildFileStream << cmVS10EscapeXML(processMax) << @@ -2180,14 +2195,14 @@ WriteMasmOptions(std::string const& configName, void cmVisualStudio10TargetGenerator::WriteLibOptions(std::string const& config) { - if(this->Target->GetType() != cmTarget::STATIC_LIBRARY && - this->Target->GetType() != cmTarget::OBJECT_LIBRARY) + if(this->GeneratorTarget->GetType() != cmState::STATIC_LIBRARY && + this->GeneratorTarget->GetType() != cmState::OBJECT_LIBRARY) { return; } std::string libflags; this->LocalGenerator->GetStaticLibraryFlags(libflags, - cmSystemTools::UpperCase(config), this->Target); + cmSystemTools::UpperCase(config), this->GeneratorTarget); if(!libflags.empty()) { this->WriteString("<Lib>\n", 2); @@ -2217,9 +2232,9 @@ cmVisualStudio10TargetGenerator::WriteLibOptions(std::string const& config) void cmVisualStudio10TargetGenerator::WriteManifestOptions( std::string const& config) { - if (this->Target->GetType() != cmTarget::EXECUTABLE && - this->Target->GetType() != cmTarget::SHARED_LIBRARY && - this->Target->GetType() != cmTarget::MODULE_LIBRARY) + if (this->GeneratorTarget->GetType() != cmState::EXECUTABLE && + this->GeneratorTarget->GetType() != cmState::SHARED_LIBRARY && + this->GeneratorTarget->GetType() != cmState::MODULE_LIBRARY) { return; } @@ -2248,7 +2263,7 @@ void cmVisualStudio10TargetGenerator::WriteAntBuildOptions( { // Look through the sources for AndroidManifest.xml and use // its location as the root source directory. - std::string rootDir = this->Makefile->GetCurrentSourceDirectory(); + std::string rootDir = this->LocalGenerator->GetCurrentSourceDirectory(); { std::vector<cmSourceFile const*> extraSources; this->GeneratorTarget->GetExtraSources(extraSources, ""); @@ -2274,18 +2289,18 @@ void cmVisualStudio10TargetGenerator::WriteAntBuildOptions( cmVS10EscapeXML(antBuildPath) << "</AntBuildPath>\n"; } - if (this->Target->GetPropertyAsBool("ANDROID_SKIP_ANT_STEP")) + if (this->GeneratorTarget->GetPropertyAsBool("ANDROID_SKIP_ANT_STEP")) { this->WriteString("<SkipAntStep>true</SkipAntStep>\n", 3); } - if (this->Target->GetPropertyAsBool("ANDROID_PROGUARD")) + if (this->GeneratorTarget->GetPropertyAsBool("ANDROID_PROGUARD")) { this->WriteString("<EnableProGuard>true</EnableProGuard>\n", 3); } if (const char* proGuardConfigLocation = - this->Target->GetProperty("ANDROID_PROGUARD_CONFIG_PATH")) + this->GeneratorTarget->GetProperty("ANDROID_PROGUARD_CONFIG_PATH")) { this->WriteString("<ProGuardConfigLocation>", 3); (*this->BuildFileStream) << cmVS10EscapeXML(proGuardConfigLocation) << @@ -2293,7 +2308,7 @@ void cmVisualStudio10TargetGenerator::WriteAntBuildOptions( } if (const char* securePropertiesLocation = - this->Target->GetProperty("ANDROID_SECURE_PROPS_PATH")) + this->GeneratorTarget->GetProperty("ANDROID_SECURE_PROPS_PATH")) { this->WriteString("<SecurePropertiesLocation>", 3); (*this->BuildFileStream) << cmVS10EscapeXML(securePropertiesLocation) << @@ -2301,31 +2316,33 @@ void cmVisualStudio10TargetGenerator::WriteAntBuildOptions( } if (const char* nativeLibDirectoriesExpression = - this->Target->GetProperty("ANDROID_NATIVE_LIB_DIRECTORIES")) + this->GeneratorTarget->GetProperty("ANDROID_NATIVE_LIB_DIRECTORIES")) { cmGeneratorExpression ge; cmsys::auto_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(nativeLibDirectoriesExpression); - std::string nativeLibDirs = cge->Evaluate(this->Makefile, configName); + std::string nativeLibDirs = cge->Evaluate(this->LocalGenerator, + configName); this->WriteString("<NativeLibDirectories>", 3); (*this->BuildFileStream) << cmVS10EscapeXML(nativeLibDirs) << "</NativeLibDirectories>\n"; } if (const char* nativeLibDependenciesExpression = - this->Target->GetProperty("ANDROID_NATIVE_LIB_DEPENDENCIES")) + this->GeneratorTarget->GetProperty("ANDROID_NATIVE_LIB_DEPENDENCIES")) { cmGeneratorExpression ge; cmsys::auto_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(nativeLibDependenciesExpression); - std::string nativeLibDeps = cge->Evaluate(this->Makefile, configName); + std::string nativeLibDeps = cge->Evaluate(this->LocalGenerator, + configName); this->WriteString("<NativeLibDependencies>", 3); (*this->BuildFileStream) << cmVS10EscapeXML(nativeLibDeps) << "</NativeLibDependencies>\n"; } if (const char* javaSourceDir = - this->Target->GetProperty("ANDROID_JAVA_SOURCE_DIR")) + this->GeneratorTarget->GetProperty("ANDROID_JAVA_SOURCE_DIR")) { this->WriteString("<JavaSourceDir>", 3); (*this->BuildFileStream) << cmVS10EscapeXML(javaSourceDir) << @@ -2333,19 +2350,20 @@ void cmVisualStudio10TargetGenerator::WriteAntBuildOptions( } if (const char* jarDirectoriesExpression = - this->Target->GetProperty("ANDROID_JAR_DIRECTORIES")) + this->GeneratorTarget->GetProperty("ANDROID_JAR_DIRECTORIES")) { cmGeneratorExpression ge; cmsys::auto_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(jarDirectoriesExpression); - std::string jarDirectories = cge->Evaluate(this->Makefile, configName); + std::string jarDirectories = cge->Evaluate(this->LocalGenerator, + configName); this->WriteString("<JarDirectories>", 3); (*this->BuildFileStream) << cmVS10EscapeXML(jarDirectories) << "</JarDirectories>\n"; } if (const char* jarDeps = - this->Target->GetProperty("ANDROID_JAR_DEPENDENCIES")) + this->GeneratorTarget->GetProperty("ANDROID_JAR_DEPENDENCIES")) { this->WriteString("<JarDependencies>", 3); (*this->BuildFileStream) << cmVS10EscapeXML(jarDeps) << @@ -2353,7 +2371,7 @@ void cmVisualStudio10TargetGenerator::WriteAntBuildOptions( } if (const char* assetsDirectories = - this->Target->GetProperty("ANDROID_ASSETS_DIRECTORIES")) + this->GeneratorTarget->GetProperty("ANDROID_ASSETS_DIRECTORIES")) { this->WriteString("<AssetsDirectories>", 3); (*this->BuildFileStream) << cmVS10EscapeXML(assetsDirectories) << @@ -2369,7 +2387,7 @@ void cmVisualStudio10TargetGenerator::WriteAntBuildOptions( } if (const char* antAdditionalOptions = - this->Target->GetProperty("ANDROID_ANT_ADDITIONAL_OPTIONS")) + this->GeneratorTarget->GetProperty("ANDROID_ANT_ADDITIONAL_OPTIONS")) { this->WriteString("<AdditionalOptions>", 3); (*this->BuildFileStream) << cmVS10EscapeXML(antAdditionalOptions) << @@ -2382,9 +2400,9 @@ void cmVisualStudio10TargetGenerator::WriteAntBuildOptions( //---------------------------------------------------------------------------- bool cmVisualStudio10TargetGenerator::ComputeLinkOptions() { - if(this->Target->GetType() == cmTarget::EXECUTABLE || - this->Target->GetType() == cmTarget::SHARED_LIBRARY || - this->Target->GetType() == cmTarget::MODULE_LIBRARY) + if(this->GeneratorTarget->GetType() == cmState::EXECUTABLE || + this->GeneratorTarget->GetType() == cmState::SHARED_LIBRARY || + this->GeneratorTarget->GetType() == cmState::MODULE_LIBRARY) { for(std::vector<std::string>::const_iterator i = this->Configurations.begin(); @@ -2421,11 +2439,11 @@ cmVisualStudio10TargetGenerator::ComputeLinkOptions(std::string const& config) std::string CONFIG = cmSystemTools::UpperCase(config); const char* linkType = "SHARED"; - if(this->Target->GetType() == cmTarget::MODULE_LIBRARY) + if(this->GeneratorTarget->GetType() == cmState::MODULE_LIBRARY) { linkType = "MODULE"; } - if(this->Target->GetType() == cmTarget::EXECUTABLE) + if(this->GeneratorTarget->GetType() == cmState::EXECUTABLE) { linkType = "EXE"; } @@ -2434,13 +2452,14 @@ cmVisualStudio10TargetGenerator::ComputeLinkOptions(std::string const& config) linkFlagVarBase += linkType; linkFlagVarBase += "_LINKER_FLAGS"; flags += " "; - flags += this-> + flags += this->GeneratorTarget-> Target->GetMakefile()->GetRequiredDefinition(linkFlagVarBase.c_str()); std::string linkFlagVar = linkFlagVarBase + "_" + CONFIG; flags += " "; - flags += this-> + flags += this->GeneratorTarget-> Target->GetMakefile()->GetRequiredDefinition(linkFlagVar.c_str()); - const char* targetLinkFlags = this->Target->GetProperty("LINK_FLAGS"); + const char* targetLinkFlags = + this->GeneratorTarget->GetProperty("LINK_FLAGS"); if(targetLinkFlags) { flags += " "; @@ -2448,7 +2467,8 @@ cmVisualStudio10TargetGenerator::ComputeLinkOptions(std::string const& config) } std::string flagsProp = "LINK_FLAGS_"; flagsProp += CONFIG; - if(const char* flagsConfig = this->Target->GetProperty(flagsProp.c_str())) + if(const char* flagsConfig = + this->GeneratorTarget->GetProperty(flagsProp.c_str())) { flags += " "; flags += flagsConfig; @@ -2508,7 +2528,7 @@ cmVisualStudio10TargetGenerator::ComputeLinkOptions(std::string const& config) std::string targetNameFull; std::string targetNameImport; std::string targetNamePDB; - if(this->Target->GetType() == cmTarget::EXECUTABLE) + if(this->GeneratorTarget->GetType() == cmState::EXECUTABLE) { this->GeneratorTarget->GetExecutableNames(targetName, targetNameFull, targetNameImport, targetNamePDB, @@ -2526,12 +2546,12 @@ cmVisualStudio10TargetGenerator::ComputeLinkOptions(std::string const& config) { linkOptions.AddFlag("Version", ""); - if ( this->Target->GetPropertyAsBool("WIN32_EXECUTABLE") ) + if ( this->GeneratorTarget->GetPropertyAsBool("WIN32_EXECUTABLE") ) { if (this->GlobalGenerator->TargetsWindowsCE()) { linkOptions.AddFlag("SubSystem", "WindowsCE"); - if (this->Target->GetType() == cmTarget::EXECUTABLE) + if (this->GeneratorTarget->GetType() == cmState::EXECUTABLE) { if (this->ClOptions[config]->UsingUnicode()) { @@ -2553,7 +2573,7 @@ cmVisualStudio10TargetGenerator::ComputeLinkOptions(std::string const& config) if (this->GlobalGenerator->TargetsWindowsCE()) { linkOptions.AddFlag("SubSystem", "WindowsCE"); - if (this->Target->GetType() == cmTarget::EXECUTABLE) + if (this->GeneratorTarget->GetType() == cmState::EXECUTABLE) { if (this->ClOptions[config]->UsingUnicode()) { @@ -2585,10 +2605,11 @@ cmVisualStudio10TargetGenerator::ComputeLinkOptions(std::string const& config) { linkOptions.AddFlag("GenerateDebugInformation", "false"); } - std::string pdb = this->Target->GetPDBDirectory(config.c_str()); + std::string pdb = this->GeneratorTarget->GetPDBDirectory(config.c_str()); pdb += "/"; pdb += targetNamePDB; - std::string imLib = this->Target->GetDirectory(config.c_str(), true); + std::string imLib = + this->GeneratorTarget->GetDirectory(config.c_str(), true); imLib += "/"; imLib += targetNameImport; @@ -2597,8 +2618,8 @@ cmVisualStudio10TargetGenerator::ComputeLinkOptions(std::string const& config) // A Windows Runtime component uses internal .NET metadata, // so does not have an import library. - if(this->Target->GetPropertyAsBool("VS_WINRT_COMPONENT") && - this->Target->GetType() != cmTarget::EXECUTABLE) + if(this->GeneratorTarget->GetPropertyAsBool("VS_WINRT_COMPONENT") && + this->GeneratorTarget->GetType() != cmState::EXECUTABLE) { linkOptions.AddFlag("GenerateWindowsMetadata", "true"); } @@ -2627,19 +2648,20 @@ cmVisualStudio10TargetGenerator::ComputeLinkOptions(std::string const& config) if(this->MSTools) { - std::string def = this->GeneratorTarget->GetModuleDefinitionFile(""); - if(!def.empty()) + if (cmSourceFile const* defsrc = + this->GeneratorTarget->GetModuleDefinitionFile("")) { - linkOptions.AddFlag("ModuleDefinitionFile", def.c_str()); + linkOptions.AddFlag("ModuleDefinitionFile", + defsrc->GetFullPath().c_str()); } linkOptions.AppendFlag("IgnoreSpecificDefaultLibraries", "%(IgnoreSpecificDefaultLibraries)"); } - if (this->Target->GetType() == cmTarget::SHARED_LIBRARY && + if (this->GeneratorTarget->GetType() == cmState::SHARED_LIBRARY && this->Makefile->IsOn("CMAKE_SUPPORT_WINDOWS_EXPORT_ALL_SYMBOLS")) { - if (this->Target->GetPropertyAsBool("WINDOWS_EXPORT_ALL_SYMBOLS")) + if (this->GeneratorTarget->GetPropertyAsBool("WINDOWS_EXPORT_ALL_SYMBOLS")) { linkOptions.AddFlag("ModuleDefinitionFile", "$(IntDir)exportall.def"); } @@ -2653,8 +2675,8 @@ cmVisualStudio10TargetGenerator::ComputeLinkOptions(std::string const& config) void cmVisualStudio10TargetGenerator::WriteLinkOptions(std::string const& config) { - if(this->Target->GetType() == cmTarget::STATIC_LIBRARY - || this->Target->GetType() > cmTarget::MODULE_LIBRARY) + if(this->GeneratorTarget->GetType() == cmState::STATIC_LIBRARY + || this->GeneratorTarget->GetType() > cmState::MODULE_LIBRARY) { return; } @@ -2665,7 +2687,8 @@ cmVisualStudio10TargetGenerator::WriteLinkOptions(std::string const& config) linkOptions.OutputFlagMap(*this->BuildFileStream, " "); this->WriteString("</Link>\n", 2); - if(!this->GlobalGenerator->NeedLinkLibraryDependencies(*this->Target)) + if(!this->GlobalGenerator->NeedLinkLibraryDependencies( + this->GeneratorTarget)) { this->WriteString("<ProjectReference>\n", 2); this->WriteString( @@ -2692,7 +2715,7 @@ void cmVisualStudio10TargetGenerator::AddLibraries( libVec.push_back(path); } else if (!l->Target - || l->Target->GetType() != cmTarget::INTERFACE_LIBRARY) + || l->Target->GetType() != cmState::INTERFACE_LIBRARY) { libVec.push_back(l->Value); } @@ -2764,7 +2787,7 @@ void cmVisualStudio10TargetGenerator::WriteItemDefinitionGroups() this->WritePlatformConfigTag("ItemDefinitionGroup", i->c_str(), 1); *this->BuildFileStream << "\n"; // output cl compile flags <ClCompile></ClCompile> - if(this->Target->GetType() <= cmTarget::OBJECT_LIBRARY) + if(this->GeneratorTarget->GetType() <= cmState::OBJECT_LIBRARY) { this->WriteClOptions(*i, includes); // output rc compile flags <ResourceCompile></ResourceCompile> @@ -2782,8 +2805,8 @@ void cmVisualStudio10TargetGenerator::WriteItemDefinitionGroups() // output manifest flags <Manifest></Manifest> this->WriteManifestOptions(*i); if(this->NsightTegra && - this->Target->GetType() == cmTarget::EXECUTABLE && - this->Target->GetPropertyAsBool("ANDROID_GUI")) + this->GeneratorTarget->GetType() == cmState::EXECUTABLE && + this->GeneratorTarget->GetPropertyAsBool("ANDROID_GUI")) { this->WriteAntBuildOptions(*i); } @@ -2795,14 +2818,14 @@ void cmVisualStudio10TargetGenerator::WriteEvents(std::string const& configName) { bool addedPrelink = false; - if (this->Target->GetType() == cmTarget::SHARED_LIBRARY && + if (this->GeneratorTarget->GetType() == cmState::SHARED_LIBRARY && this->Makefile->IsOn("CMAKE_SUPPORT_WINDOWS_EXPORT_ALL_SYMBOLS")) { - if (this->Target->GetPropertyAsBool("WINDOWS_EXPORT_ALL_SYMBOLS")) + if (this->GeneratorTarget->GetPropertyAsBool("WINDOWS_EXPORT_ALL_SYMBOLS")) { addedPrelink = true; std::vector<cmCustomCommand> commands = - this->Target->GetPreLinkCommands(); + this->GeneratorTarget->GetPreLinkCommands(); this->GlobalGenerator->AddSymbolExportCommand( this->GeneratorTarget, commands, configName); this->WriteEvent("PreLinkEvent", commands, configName); @@ -2811,12 +2834,12 @@ cmVisualStudio10TargetGenerator::WriteEvents(std::string const& configName) if (!addedPrelink) { this->WriteEvent("PreLinkEvent", - this->Target->GetPreLinkCommands(), configName); + this->GeneratorTarget->GetPreLinkCommands(), configName); } this->WriteEvent("PreBuildEvent", - this->Target->GetPreBuildCommands(), configName); + this->GeneratorTarget->GetPreBuildCommands(), configName); this->WriteEvent("PostBuildEvent", - this->Target->GetPostBuildCommands(), configName); + this->GeneratorTarget->GetPostBuildCommands(), configName); } void cmVisualStudio10TargetGenerator::WriteEvent( @@ -2866,20 +2889,20 @@ void cmVisualStudio10TargetGenerator::WriteProjectReferences() for( OrderedTargetDependSet::const_iterator i = depends.begin(); i != depends.end(); ++i) { - cmTarget const* dt = (*i)->Target; - if(dt->GetType() == cmTarget::INTERFACE_LIBRARY) + cmGeneratorTarget const* dt = *i; + if(dt->GetType() == cmState::INTERFACE_LIBRARY) { continue; } // skip fortran targets as they can not be processed by MSBuild // the only reference will be in the .sln file if(static_cast<cmGlobalVisualStudioGenerator*>(this->GlobalGenerator) - ->TargetIsFortranOnly(*dt)) + ->TargetIsFortranOnly(dt)) { continue; } this->WriteString("<ProjectReference Include=\"", 2); - cmMakefile* mf = dt->GetMakefile(); + cmLocalGenerator* lg = dt->GetLocalGenerator(); std::string name = dt->GetName(); std::string path; const char* p = dt->GetProperty("EXTERNAL_MSPROJECT"); @@ -2889,7 +2912,7 @@ void cmVisualStudio10TargetGenerator::WriteProjectReferences() } else { - path = mf->GetCurrentBinaryDirectory(); + path = lg->GetCurrentBinaryDirectory(); path += "/"; path += dt->GetName(); path += ".vcxproj"; @@ -2911,14 +2934,14 @@ void cmVisualStudio10TargetGenerator::WritePlatformExtensions() cmHasLiteralPrefix(this->GlobalGenerator->GetSystemVersion(), "10.0")) { const char* desktopExtensionsVersion = - this->Target->GetProperty("VS_DESKTOP_EXTENSIONS_VERSION"); + this->GeneratorTarget->GetProperty("VS_DESKTOP_EXTENSIONS_VERSION"); if (desktopExtensionsVersion) { this->WriteSinglePlatformExtension("WindowsDesktop", desktopExtensionsVersion); } const char* mobileExtensionsVersion = - this->Target->GetProperty("VS_MOBILE_EXTENSIONS_VERSION"); + this->GeneratorTarget->GetProperty("VS_MOBILE_EXTENSIONS_VERSION"); if (mobileExtensionsVersion) { this->WriteSinglePlatformExtension("WindowsMobile", @@ -2958,11 +2981,11 @@ void cmVisualStudio10TargetGenerator::WriteSDKReferences() cmHasLiteralPrefix(this->GlobalGenerator->GetSystemVersion(), "10.0")) { const char* desktopExtensionsVersion = - this->Target->GetProperty("VS_DESKTOP_EXTENSIONS_VERSION"); + this->GeneratorTarget->GetProperty("VS_DESKTOP_EXTENSIONS_VERSION"); const char* mobileExtensionsVersion = - this->Target->GetProperty("VS_MOBILE_EXTENSIONS_VERSION"); + this->GeneratorTarget->GetProperty("VS_MOBILE_EXTENSIONS_VERSION"); const char* iotExtensionsVersion = - this->Target->GetProperty("VS_IOT_EXTENSIONS_VERSION"); + this->GeneratorTarget->GetProperty("VS_IOT_EXTENSIONS_VERSION"); if(desktopExtensionsVersion || mobileExtensionsVersion || iotExtensionsVersion) @@ -3003,7 +3026,7 @@ void cmVisualStudio10TargetGenerator::WriteWinRTPackageCertificateKeyFile() { if((this->GlobalGenerator->TargetsWindowsStore() || this->GlobalGenerator->TargetsWindowsPhone()) - && (cmTarget::EXECUTABLE == this->Target->GetType())) + && (cmState::EXECUTABLE == this->GeneratorTarget->GetType())) { std::string pfxFile; std::vector<cmSourceFile const*> certificates; @@ -3022,7 +3045,7 @@ void cmVisualStudio10TargetGenerator::WriteWinRTPackageCertificateKeyFile() { // Move the manifest to a project directory to avoid clashes std::string artifactDir = - this->LocalGenerator->GetTargetDirectory(*this->Target); + this->LocalGenerator->GetTargetDirectory(this->GeneratorTarget); this->ConvertToWindowsSlash(artifactDir); this->WriteString("<PropertyGroup>\n", 1); this->WriteString("<AppxPackageArtifactsDir>", 2); @@ -3132,7 +3155,7 @@ void cmVisualStudio10TargetGenerator::WriteApplicationTypeSettings() this->WriteString("<MinimumVisualStudioVersion>14.0" "</MinimumVisualStudioVersion>\n", 2); - if(this->Target->GetType() < cmTarget::UTILITY) + if(this->GeneratorTarget->GetType() < cmState::UTILITY) { isAppContainer = true; } @@ -3146,7 +3169,7 @@ void cmVisualStudio10TargetGenerator::WriteApplicationTypeSettings() this->WriteString("<MinimumVisualStudioVersion>12.0" "</MinimumVisualStudioVersion>\n", 2); - if (this->Target->GetType() < cmTarget::UTILITY) + if (this->GeneratorTarget->GetType() < cmState::UTILITY) { isAppContainer = true; } @@ -3160,12 +3183,13 @@ void cmVisualStudio10TargetGenerator::WriteApplicationTypeSettings() this->WriteString("<MinimumVisualStudioVersion>11.0" "</MinimumVisualStudioVersion>\n", 2); - if (isWindowsStore && this->Target->GetType() < cmTarget::UTILITY) + if (isWindowsStore + && this->GeneratorTarget->GetType() < cmState::UTILITY) { isAppContainer = true; } else if (isWindowsPhone && - this->Target->GetType() == cmTarget::EXECUTABLE) + this->GeneratorTarget->GetType() == cmState::EXECUTABLE) { this->WriteString("<XapOutputs>true</XapOutputs>\n", 2); this->WriteString("<XapFilename>", 2); @@ -3193,7 +3217,8 @@ void cmVisualStudio10TargetGenerator::WriteApplicationTypeSettings() "</WindowsTargetPlatformVersion>\n"; } const char* targetPlatformMinVersion = - this->Target->GetProperty("VS_WINDOWS_TARGET_PLATFORM_MIN_VERSION"); + this->GeneratorTarget + ->GetProperty("VS_WINDOWS_TARGET_PLATFORM_MIN_VERSION"); if(targetPlatformMinVersion) { this->WriteString("<WindowsTargetPlatformMinVersion>", 2); @@ -3212,7 +3237,7 @@ void cmVisualStudio10TargetGenerator::WriteApplicationTypeSettings() } // Added IoT Startup Task support - if(this->Target->GetPropertyAsBool("VS_IOT_STARTUP_TASK")) + if(this->GeneratorTarget->GetPropertyAsBool("VS_IOT_STARTUP_TASK")) { this->WriteString("<ContainsStartupTask>true</ContainsStartupTask>\n", 2); } @@ -3222,7 +3247,7 @@ void cmVisualStudio10TargetGenerator::VerifyNecessaryFiles() { // For Windows and Windows Phone executables, we will assume that if a // manifest is not present that we need to add all the necessary files - if (this->Target->GetType() == cmTarget::EXECUTABLE) + if (this->GeneratorTarget->GetType() == cmState::EXECUTABLE) { std::vector<cmSourceFile const*> manifestSources; this->GeneratorTarget->GetAppManifest(manifestSources, ""); @@ -3317,13 +3342,15 @@ void cmVisualStudio10TargetGenerator::WriteMissingFilesWP80() // For WP80, the manifest needs to be in the same folder as the project // this can cause an overwrite problem if projects aren't organized in // folders - std::string manifestFile = this->Makefile->GetCurrentBinaryDirectory() + + std::string manifestFile = + this->LocalGenerator->GetCurrentBinaryDirectory() + std::string("/WMAppManifest.xml"); std::string artifactDir = - this->LocalGenerator->GetTargetDirectory(*this->Target); + this->LocalGenerator->GetTargetDirectory(this->GeneratorTarget); this->ConvertToWindowsSlash(artifactDir); std::string artifactDirXML = cmVS10EscapeXML(artifactDir); - std::string targetNameXML = cmVS10EscapeXML(this->Target->GetName()); + std::string targetNameXML = + cmVS10EscapeXML(this->GeneratorTarget->GetName()); cmGeneratedFileStream fout(manifestFile.c_str()); fout.SetCopyIfDifferent(true); @@ -3403,10 +3430,11 @@ void cmVisualStudio10TargetGenerator::WriteMissingFilesWP81() std::string manifestFile = this->DefaultArtifactDir + "/package.appxManifest"; std::string artifactDir = - this->LocalGenerator->GetTargetDirectory(*this->Target); + this->LocalGenerator->GetTargetDirectory(this->GeneratorTarget); this->ConvertToWindowsSlash(artifactDir); std::string artifactDirXML = cmVS10EscapeXML(artifactDir); - std::string targetNameXML = cmVS10EscapeXML(this->Target->GetName()); + std::string targetNameXML = + cmVS10EscapeXML(this->GeneratorTarget->GetName()); cmGeneratedFileStream fout(manifestFile.c_str()); fout.SetCopyIfDifferent(true); @@ -3463,10 +3491,11 @@ void cmVisualStudio10TargetGenerator::WriteMissingFilesWS80() std::string manifestFile = this->DefaultArtifactDir + "/package.appxManifest"; std::string artifactDir = - this->LocalGenerator->GetTargetDirectory(*this->Target); + this->LocalGenerator->GetTargetDirectory(this->GeneratorTarget); this->ConvertToWindowsSlash(artifactDir); std::string artifactDirXML = cmVS10EscapeXML(artifactDir); - std::string targetNameXML = cmVS10EscapeXML(this->Target->GetName()); + std::string targetNameXML = + cmVS10EscapeXML(this->GeneratorTarget->GetName()); cmGeneratedFileStream fout(manifestFile.c_str()); fout.SetCopyIfDifferent(true); @@ -3515,10 +3544,11 @@ void cmVisualStudio10TargetGenerator::WriteMissingFilesWS81() std::string manifestFile = this->DefaultArtifactDir + "/package.appxManifest"; std::string artifactDir = - this->LocalGenerator->GetTargetDirectory(*this->Target); + this->LocalGenerator->GetTargetDirectory(this->GeneratorTarget); this->ConvertToWindowsSlash(artifactDir); std::string artifactDirXML = cmVS10EscapeXML(artifactDir); - std::string targetNameXML = cmVS10EscapeXML(this->Target->GetName()); + std::string targetNameXML = + cmVS10EscapeXML(this->GeneratorTarget->GetName()); cmGeneratedFileStream fout(manifestFile.c_str()); fout.SetCopyIfDifferent(true); @@ -3572,10 +3602,11 @@ void cmVisualStudio10TargetGenerator::WriteMissingFilesWS10_0() std::string manifestFile = this->DefaultArtifactDir + "/package.appxManifest"; std::string artifactDir = - this->LocalGenerator->GetTargetDirectory(*this->Target); + this->LocalGenerator->GetTargetDirectory(this->GeneratorTarget); this->ConvertToWindowsSlash(artifactDir); std::string artifactDirXML = cmVS10EscapeXML(artifactDir); - std::string targetNameXML = cmVS10EscapeXML(this->Target->GetName()); + std::string targetNameXML = + cmVS10EscapeXML(this->GeneratorTarget->GetName()); cmGeneratedFileStream fout(manifestFile.c_str()); fout.SetCopyIfDifferent(true); diff --git a/Source/cmVisualStudio10TargetGenerator.h b/Source/cmVisualStudio10TargetGenerator.h index 15ed9f2..044e0dd 100644 --- a/Source/cmVisualStudio10TargetGenerator.h +++ b/Source/cmVisualStudio10TargetGenerator.h @@ -13,7 +13,6 @@ #define cmVisualStudioTargetGenerator_h #include "cmStandardIncludes.h" -class cmTarget; class cmMakefile; class cmGeneratorTarget; class cmGeneratedFileStream; @@ -29,7 +28,7 @@ struct cmIDEFlagTable; class cmVisualStudio10TargetGenerator { public: - cmVisualStudio10TargetGenerator(cmTarget* target, + cmVisualStudio10TargetGenerator(cmGeneratorTarget* target, cmGlobalVisualStudio10Generator* gg); ~cmVisualStudio10TargetGenerator(); void Generate(); @@ -148,7 +147,6 @@ private: OptionsMap LinkOptions; std::string PathToVcxproj; std::vector<std::string> Configurations; - cmTarget* Target; cmGeneratorTarget* GeneratorTarget; cmMakefile* Makefile; std::string Platform; diff --git a/Source/cmXCodeObject.h b/Source/cmXCodeObject.h index ed2940a..bd0f43f 100644 --- a/Source/cmXCodeObject.h +++ b/Source/cmXCodeObject.h @@ -13,7 +13,7 @@ #define cmXCodeObject_h #include "cmStandardIncludes.h" -class cmTarget; +class cmGeneratorTarget; class cmXCodeObject { @@ -75,7 +75,7 @@ public: } static void Indent(int level, std::ostream& out); void Print(std::ostream& out); - virtual void PrintComment(std::ostream&) {}; + virtual void PrintComment(std::ostream&) {} static void PrintList(std::vector<cmXCodeObject*> const&, std::ostream& out); @@ -87,11 +87,11 @@ public: { this->Id = id; } - cmTarget* GetTarget() + cmGeneratorTarget* GetTarget() { return this->Target; } - void SetTarget(cmTarget* t) + void SetTarget(cmGeneratorTarget* t) { this->Target = t; } @@ -105,7 +105,7 @@ public: } return 0; } - // serach the attribute list for an object of the specified type + // search the attribute list for an object of the specified type cmXCodeObject* GetObject(cmXCodeObject::PBXType t) { for(std::vector<cmXCodeObject*>::iterator i = this->List.begin(); @@ -146,7 +146,7 @@ public: protected: void PrintString(std::ostream& os) const; - cmTarget* Target; + cmGeneratorTarget* Target; Type TypeValue; std::string Id; PBXType IsA; diff --git a/Source/cmake.cxx b/Source/cmake.cxx index 386f6a5..ee1e878 100644 --- a/Source/cmake.cxx +++ b/Source/cmake.cxx @@ -10,7 +10,6 @@ See the License for more information. ============================================================================*/ #include "cmake.h" -#include "cmCacheManager.h" #include "cmMakefile.h" #include "cmLocalGenerator.h" #include "cmExternalMakefileProjectGenerator.h" @@ -135,7 +134,7 @@ cmake::cmake() this->ClearBuildSystem = false; this->FileComparison = new cmFileTimeComparison; - this->State = new cmState(this); + this->State = new cmState; this->CurrentSnapshot = this->State->CreateBaseSnapshot(); #ifdef __APPLE__ @@ -151,7 +150,6 @@ cmake::cmake() #endif this->Verbose = false; - this->CacheManager = new cmCacheManager(this); this->GlobalGenerator = 0; this->ProgressCallback = 0; this->ProgressCallbackClientData = 0; @@ -167,11 +165,34 @@ cmake::cmake() // Make sure we can capture the build tool output. cmSystemTools::EnableVSConsoleOutput(); + + // Set up a list of source and header extensions + // these are used to find files when the extension + // is not given + // The "c" extension MUST precede the "C" extension. + this->SourceFileExtensions.push_back( "c" ); + this->SourceFileExtensions.push_back( "C" ); + + this->SourceFileExtensions.push_back( "c++" ); + this->SourceFileExtensions.push_back( "cc" ); + this->SourceFileExtensions.push_back( "cpp" ); + this->SourceFileExtensions.push_back( "cxx" ); + this->SourceFileExtensions.push_back( "m" ); + this->SourceFileExtensions.push_back( "M" ); + this->SourceFileExtensions.push_back( "mm" ); + + this->HeaderFileExtensions.push_back( "h" ); + this->HeaderFileExtensions.push_back( "hh" ); + this->HeaderFileExtensions.push_back( "h++" ); + this->HeaderFileExtensions.push_back( "hm" ); + this->HeaderFileExtensions.push_back( "hpp" ); + this->HeaderFileExtensions.push_back( "hxx" ); + this->HeaderFileExtensions.push_back( "in" ); + this->HeaderFileExtensions.push_back( "txx" ); } cmake::~cmake() { - delete this->CacheManager; delete this->State; if (this->GlobalGenerator) { @@ -189,6 +210,7 @@ void cmake::CleanupCommandsAndMacros() { this->CurrentSnapshot = this->State->Reset(); this->State->RemoveUserDefinedCommands(); + this->CurrentSnapshot.SetDefaultDefinitions(); } // Parse the args @@ -216,7 +238,7 @@ bool cmake::SetCacheArgs(const std::vector<std::string>& args) } std::string var, value; cmState::CacheEntryType type = cmState::UNINITIALIZED; - if(cmCacheManager::ParseEntry(entry, var, value, type)) + if(cmState::ParseCacheEntry(entry, var, value, type)) { // The value is transformed if it is a filepath for example, so // we can't compare whether the value is already in the cache until @@ -232,7 +254,7 @@ bool cmake::SetCacheArgs(const std::vector<std::string>& args) } } - this->State->AddCacheEntry(var, value.c_str(), + this->AddCacheEntry(var, value.c_str(), "No help, variable specified on the command line.", type); if(this->WarnUnusedCli) @@ -377,21 +399,21 @@ void cmake::ReadListFile(const std::vector<std::string>& args, this->SetHomeDirectory(cmSystemTools::GetCurrentWorkingDirectory()); this->SetHomeOutputDirectory(cmSystemTools::GetCurrentWorkingDirectory()); cmState::Snapshot snapshot = this->GetCurrentSnapshot(); - cmsys::auto_ptr<cmMakefile> mf(new cmMakefile(gg, snapshot)); - cmsys::auto_ptr<cmLocalGenerator> lg(gg->CreateLocalGenerator(mf.get())); - lg->GetMakefile()->SetCurrentBinaryDirectory + snapshot.GetDirectory().SetCurrentBinary (cmSystemTools::GetCurrentWorkingDirectory()); - lg->GetMakefile()->SetCurrentSourceDirectory + snapshot.GetDirectory().SetCurrentSource (cmSystemTools::GetCurrentWorkingDirectory()); + snapshot.SetDefaultDefinitions(); + cmsys::auto_ptr<cmMakefile> mf(new cmMakefile(gg, snapshot)); if (this->GetWorkingMode() != NORMAL_MODE) { std::string file(cmSystemTools::CollapseFullPath(path)); cmSystemTools::ConvertToUnixSlashes(file); - lg->GetMakefile()->SetScriptModeFile(file.c_str()); + mf->SetScriptModeFile(file.c_str()); - lg->GetMakefile()->SetArgcArgv(args); + mf->SetArgcArgv(args); } - if (!lg->GetMakefile()->ReadListFile(path)) + if (!mf->ReadListFile(path)) { cmSystemTools::Error("Error processing file: ", path); } @@ -419,13 +441,14 @@ bool cmake::FindPackage(const std::vector<std::string>& args) this->SetGlobalGenerator(gg); cmState::Snapshot snapshot = this->GetCurrentSnapshot(); - // read in the list file to fill the cache - cmsys::auto_ptr<cmMakefile> mf(new cmMakefile(gg, snapshot)); - cmsys::auto_ptr<cmLocalGenerator> lg(gg->CreateLocalGenerator(mf.get())); - mf->SetCurrentBinaryDirectory + snapshot.GetDirectory().SetCurrentBinary (cmSystemTools::GetCurrentWorkingDirectory()); - mf->SetCurrentSourceDirectory + snapshot.GetDirectory().SetCurrentSource (cmSystemTools::GetCurrentWorkingDirectory()); + // read in the list file to fill the cache + snapshot.SetDefaultDefinitions(); + cmMakefile* mf = new cmMakefile(gg, snapshot); + gg->AddMakefile(mf); mf->SetArgcArgv(args); @@ -458,6 +481,8 @@ bool cmake::FindPackage(const std::vector<std::string>& args) std::vector<std::string> includeDirs; cmSystemTools::ExpandListArgument(includes, includeDirs); + gg->CreateGenerationObjects(); + cmLocalGenerator* lg = gg->LocalGenerators[0]; std::string includeFlags = lg->GetIncludeFlags(includeDirs, 0, language); std::string definitions = mf->GetSafeDefinition("PACKAGE_DEFINITIONS"); @@ -478,7 +503,7 @@ bool cmake::FindPackage(const std::vector<std::string>& args) ++libIt) { mf->AddLinkLibraryForTarget(targetName, *libIt, - cmTarget::GENERAL); + GENERAL_LibraryType); } @@ -487,8 +512,9 @@ bool cmake::FindPackage(const std::vector<std::string>& args) std::string linkPath; std::string flags; std::string linkFlags; - gg->CreateGeneratorTargets(cmGlobalGenerator::AllTargets, lg.get()); - cmGeneratorTarget *gtgt = gg->GetGeneratorTarget(tgt); + gg->CreateGenerationObjects(); + cmGeneratorTarget *gtgt = gg->FindGeneratorTarget(tgt->GetName()); + cmLocalGenerator* lg = gtgt->GetLocalGenerator(); lg->GetTargetFlags(linkLibs, frameworkPath, linkPath, flags, linkFlags, gtgt, false); linkLibs = frameworkPath + linkPath + linkLibs; @@ -849,14 +875,14 @@ void cmake::SetDirectoriesFromFile(const char* arg) int cmake::AddCMakePaths() { // Save the value in the cache - this->CacheManager->AddCacheEntry + this->AddCacheEntry ("CMAKE_COMMAND", cmSystemTools::GetCMakeCommand().c_str(), "Path to CMake executable.", cmState::INTERNAL); #ifdef CMAKE_BUILD_WITH_CMAKE - this->CacheManager->AddCacheEntry + this->AddCacheEntry ("CMAKE_CTEST_COMMAND", cmSystemTools::GetCTestCommand().c_str(), "Path to ctest program executable.", cmState::INTERNAL); - this->CacheManager->AddCacheEntry + this->AddCacheEntry ("CMAKE_CPACK_COMMAND", cmSystemTools::GetCPackCommand().c_str(), "Path to cpack program executable.", cmState::INTERNAL); #endif @@ -870,7 +896,7 @@ int cmake::AddCMakePaths() cmSystemTools::GetCMakeRoot().c_str()); return 0; } - this->CacheManager->AddCacheEntry + this->AddCacheEntry ("CMAKE_ROOT", cmSystemTools::GetCMakeRoot().c_str(), "Path to CMake installation.", cmState::INTERNAL); @@ -931,18 +957,32 @@ void cmake::AddDefaultExtraGenerators() //---------------------------------------------------------------------------- -void cmake::GetRegisteredGenerators(std::vector<std::string>& names) +void cmake::GetRegisteredGenerators(std::vector<GeneratorInfo>& generators) { - for(RegisteredGeneratorsVector::const_iterator i = this->Generators.begin(); - i != this->Generators.end(); ++i) + for (RegisteredGeneratorsVector::const_iterator + i = this->Generators.begin(), e = this->Generators.end(); + i != e; ++i) { + std::vector<std::string> names; (*i)->GetGenerators(names); + + for (size_t j = 0; j < names.size(); ++j) + { + GeneratorInfo info; + info.supportsToolset = (*i)->SupportsToolset(); + info.name = names[j]; + generators.push_back(info); + } } - for(RegisteredExtraGeneratorsMap::const_iterator - i = this->ExtraGenerators.begin(); - i != this->ExtraGenerators.end(); ++i) + + for (RegisteredExtraGeneratorsMap::const_iterator + i = this->ExtraGenerators.begin(), e = this->ExtraGenerators.end(); + i != e; ++i) { - names.push_back(i->first); + GeneratorInfo info; + info.name = i->first; + info.supportsToolset = false; + generators.push_back(info); } } @@ -984,6 +1024,10 @@ cmGlobalGenerator* cmake::CreateGlobalGenerator(const std::string& gname) void cmake::SetHomeDirectory(const std::string& dir) { this->State->SetSourceDirectory(dir); + if (this->CurrentSnapshot.IsValid()) + { + this->CurrentSnapshot.SetDefinition("CMAKE_SOURCE_DIR", dir); + } } const char* cmake::GetHomeDirectory() const @@ -994,6 +1038,10 @@ const char* cmake::GetHomeDirectory() const void cmake::SetHomeOutputDirectory(const std::string& dir) { this->State->SetBinaryDirectory(dir); + if (this->CurrentSnapshot.IsValid()) + { + this->CurrentSnapshot.SetDefinition("CMAKE_BINARY_DIR", dir); + } } const char* cmake::GetHomeOutputDirectory() const @@ -1087,10 +1135,10 @@ int cmake::DoPreConfigureChecks() } // do a sanity check on some values - if(this->CacheManager->GetInitializedCacheValue("CMAKE_HOME_DIRECTORY")) + if(this->State->GetInitializedCacheValue("CMAKE_HOME_DIRECTORY")) { std::string cacheStart = - this->CacheManager->GetInitializedCacheValue("CMAKE_HOME_DIRECTORY"); + this->State->GetInitializedCacheValue("CMAKE_HOME_DIRECTORY"); cacheStart += "/CMakeLists.txt"; std::string currentStart = this->GetHomeDirectory(); currentStart += "/CMakeLists.txt"; @@ -1147,12 +1195,12 @@ int cmake::HandleDeleteCacheVariables(const std::string& var) save.value = *i; warning << *i << "\n"; const char* existingValue = - this->CacheManager->GetCacheEntryValue(save.key); + this->State->GetCacheEntryValue(save.key); if(existingValue) { - save.type = this->CacheManager->GetCacheEntryType(save.key); + save.type = this->State->GetCacheEntryType(save.key); if(const char* help = - this->CacheManager->GetCacheEntryProperty(save.key, "HELPSTRING")) + this->State->GetCacheEntryProperty(save.key, "HELPSTRING")) { save.help = help; } @@ -1161,7 +1209,7 @@ int cmake::HandleDeleteCacheVariables(const std::string& var) } // remove the cache - this->CacheManager->DeleteCache(this->GetHomeOutputDirectory()); + this->DeleteCache(this->GetHomeOutputDirectory()); // load the empty cache this->LoadCache(); // restore the changed compilers @@ -1187,7 +1235,7 @@ int cmake::Configure() { if(this->SuppressDevWarnings) { - this->CacheManager-> + this-> AddCacheEntry("CMAKE_SUPPRESS_DEVELOPER_WARNINGS", "TRUE", "Suppress Warnings that are meant for" " the author of the CMakeLists.txt files.", @@ -1195,7 +1243,7 @@ int cmake::Configure() } else { - this->CacheManager-> + this-> AddCacheEntry("CMAKE_SUPPRESS_DEVELOPER_WARNINGS", "FALSE", "Suppress Warnings that are meant for" " the author of the CMakeLists.txt files.", @@ -1230,7 +1278,7 @@ int cmake::ActualConfigure() } if ( !res ) { - this->CacheManager->AddCacheEntry + this->AddCacheEntry ("CMAKE_HOME_DIRECTORY", this->GetHomeDirectory(), "Source directory with the top level CMakeLists.txt file for this " @@ -1242,9 +1290,9 @@ int cmake::ActualConfigure() if(!this->GlobalGenerator) { const char* genName = - this->CacheManager->GetInitializedCacheValue("CMAKE_GENERATOR"); + this->State->GetInitializedCacheValue("CMAKE_GENERATOR"); const char* extraGenName = - this->CacheManager->GetInitializedCacheValue("CMAKE_EXTRA_GENERATOR"); + this->State->GetInitializedCacheValue("CMAKE_EXTRA_GENERATOR"); if(genName) { std::string fullName = cmExternalMakefileProjectGenerator:: @@ -1322,7 +1370,7 @@ int cmake::ActualConfigure() } } - const char* genName = this->CacheManager + const char* genName = this->State ->GetInitializedCacheValue("CMAKE_GENERATOR"); if(genName) { @@ -1339,20 +1387,20 @@ int cmake::ActualConfigure() return -2; } } - if(!this->CacheManager->GetInitializedCacheValue("CMAKE_GENERATOR")) + if(!this->State->GetInitializedCacheValue("CMAKE_GENERATOR")) { - this->CacheManager->AddCacheEntry("CMAKE_GENERATOR", + this->AddCacheEntry("CMAKE_GENERATOR", this->GlobalGenerator->GetName().c_str(), "Name of generator.", cmState::INTERNAL); - this->CacheManager->AddCacheEntry("CMAKE_EXTRA_GENERATOR", + this->AddCacheEntry("CMAKE_EXTRA_GENERATOR", this->GlobalGenerator->GetExtraGeneratorName().c_str(), "Name of external makefile project generator.", cmState::INTERNAL); } if(const char* platformName = - this->CacheManager->GetInitializedCacheValue("CMAKE_GENERATOR_PLATFORM")) + this->State->GetInitializedCacheValue("CMAKE_GENERATOR_PLATFORM")) { if(this->GeneratorPlatform.empty()) { @@ -1373,14 +1421,14 @@ int cmake::ActualConfigure() } else { - this->CacheManager->AddCacheEntry("CMAKE_GENERATOR_PLATFORM", + this->AddCacheEntry("CMAKE_GENERATOR_PLATFORM", this->GeneratorPlatform.c_str(), "Name of generator platform.", cmState::INTERNAL); } if(const char* tsName = - this->CacheManager->GetInitializedCacheValue("CMAKE_GENERATOR_TOOLSET")) + this->State->GetInitializedCacheValue("CMAKE_GENERATOR_TOOLSET")) { if(this->GeneratorToolset.empty()) { @@ -1401,7 +1449,7 @@ int cmake::ActualConfigure() } else { - this->CacheManager->AddCacheEntry("CMAKE_GENERATOR_TOOLSET", + this->AddCacheEntry("CMAKE_GENERATOR_TOOLSET", this->GeneratorToolset.c_str(), "Name of generator toolset.", cmState::INTERNAL); @@ -1435,7 +1483,7 @@ int cmake::ActualConfigure() { if(!this->State->GetInitializedCacheValue("LIBRARY_OUTPUT_PATH")) { - this->State->AddCacheEntry + this->AddCacheEntry ("LIBRARY_OUTPUT_PATH", "", "Single output directory for building all libraries.", cmState::PATH); @@ -1443,7 +1491,7 @@ int cmake::ActualConfigure() if(!this->State ->GetInitializedCacheValue("EXECUTABLE_OUTPUT_PATH")) { - this->State->AddCacheEntry + this->AddCacheEntry ("EXECUTABLE_OUTPUT_PATH", "", "Single output directory for building all executables.", cmState::PATH); @@ -1463,7 +1511,7 @@ int cmake::ActualConfigure() // only save the cache if there were no fatal errors if ( this->GetWorkingMode() == NORMAL_MODE ) { - this->CacheManager->SaveCache(this->GetHomeOutputDirectory()); + this->SaveCache(this->GetHomeOutputDirectory()); } if(cmSystemTools::GetErrorOccuredFlag()) { @@ -1633,7 +1681,7 @@ int cmake::Generate() // for the Visual Studio and Xcode generators.) if ( this->GetWorkingMode() == NORMAL_MODE ) { - this->CacheManager->SaveCache(this->GetHomeOutputDirectory()); + this->SaveCache(this->GetHomeOutputDirectory()); } return 0; } @@ -1642,14 +1690,15 @@ void cmake::AddCacheEntry(const std::string& key, const char* value, const char* helpString, int type) { - this->CacheManager->AddCacheEntry(key, value, + this->State->AddCacheEntry(key, value, helpString, cmState::CacheEntryType(type)); + this->UnwatchUnusedCli(key); } const char* cmake::GetCacheDefinition(const std::string& name) const { - return this->CacheManager->GetInitializedCacheValue(name); + return this->State->GetInitializedCacheValue(name); } void cmake::AddDefaultCommands() @@ -1722,7 +1771,7 @@ bool cmake::ParseCacheEntry(const std::string& entry, std::string& value, cmState::CacheEntryType& type) { - return cmCacheManager::ParseEntry(entry, var, value, type); + return cmState::ParseCacheEntry(entry, var, value, type); } int cmake::LoadCache() @@ -1753,24 +1802,43 @@ int cmake::LoadCache() bool cmake::LoadCache(const std::string& path) { - return this->CacheManager->LoadCache(path); + std::set<std::string> emptySet; + return this->LoadCache(path, true, emptySet, emptySet); } bool cmake::LoadCache(const std::string& path, bool internal, std::set<std::string>& excludes, std::set<std::string>& includes) { - return this->CacheManager->LoadCache(path, internal, excludes, includes); + bool result = this->State->LoadCache(path, internal, excludes, includes); + static const char* entries[] = {"CMAKE_CACHE_MAJOR_VERSION", + "CMAKE_CACHE_MINOR_VERSION"}; + for (const char* const* nameIt = cmArrayBegin(entries); + nameIt != cmArrayEnd(entries); ++nameIt) + { + this->UnwatchUnusedCli(*nameIt); + } + return result; } bool cmake::SaveCache(const std::string& path) { - return this->CacheManager->SaveCache(path); + bool result = this->State->SaveCache(path); + static const char* entries[] = {"CMAKE_CACHE_MAJOR_VERSION", + "CMAKE_CACHE_MINOR_VERSION", + "CMAKE_CACHE_PATCH_VERSION", + "CMAKE_CACHEFILE_DIR"}; + for (const char* const* nameIt = cmArrayBegin(entries); + nameIt != cmArrayEnd(entries); ++nameIt) + { + this->UnwatchUnusedCli(*nameIt); + } + return result; } bool cmake::DeleteCache(const std::string& path) { - return this->CacheManager->DeleteCache(path); + return this->State->DeleteCache(path); } void cmake::SetProgressCallback(ProgressCallbackType f, void *cd) @@ -1835,7 +1903,7 @@ void cmake::UpdateConversionPathTable() { // Update the path conversion table with any specified file: const char* tablepath = - this->CacheManager + this->State ->GetInitializedCacheValue("CMAKE_PATH_TRANSLATION_FILE"); if(tablepath) @@ -1904,9 +1972,9 @@ int cmake::CheckBuildSystem() cmake cm; cm.SetHomeDirectory(""); cm.SetHomeOutputDirectory(""); + cm.GetCurrentSnapshot().SetDefaultDefinitions(); cmGlobalGenerator gg(&cm); cmsys::auto_ptr<cmMakefile> mf(new cmMakefile(&gg, cm.GetCurrentSnapshot())); - cmsys::auto_ptr<cmLocalGenerator> lg(gg.CreateLocalGenerator(mf.get())); if(!mf->ReadListFile(this->CheckBuildSystemArgument.c_str()) || cmSystemTools::GetErrorOccuredFlag()) { @@ -1935,6 +2003,7 @@ int cmake::CheckBuildSystem() ggd(this->CreateGlobalGenerator(genName)); if(ggd.get()) { + cm.GetCurrentSnapshot().SetDefaultDefinitions(); cmsys::auto_ptr<cmMakefile> mfd(new cmMakefile(ggd.get(), cm.GetCurrentSnapshot())); cmsys::auto_ptr<cmLocalGenerator> lgd( diff --git a/Source/cmake.h b/Source/cmake.h index 9d28cba..c584ad9 100644 --- a/Source/cmake.h +++ b/Source/cmake.h @@ -89,6 +89,13 @@ class cmake */ FIND_PACKAGE_MODE }; + + struct GeneratorInfo + { + std::string name; + bool supportsToolset; + }; + typedef std::map<std::string, cmInstalledFile> InstalledFilesMap; /// Default constructor @@ -161,7 +168,7 @@ class cmake void SetGlobalGenerator(cmGlobalGenerator *); ///! Get the names of the current registered generators - void GetRegisteredGenerators(std::vector<std::string>& names); + void GetRegisteredGenerators(std::vector<GeneratorInfo>& generators); ///! Set the name of the selected generator-specific platform. void SetGeneratorPlatform(std::string const& ts) @@ -182,6 +189,11 @@ class cmake ///! get the cmCachemManager used by this invocation of cmake cmCacheManager *GetCacheManager() { return this->CacheManager; } + const std::vector<std::string>& GetSourceExtensions() const + {return this->SourceFileExtensions;} + const std::vector<std::string>& GetHeaderExtensions() const + {return this->HeaderFileExtensions;} + /** * Given a variable name, return its value (as a string). */ @@ -391,6 +403,8 @@ private: std::string CheckStampFile; std::string CheckStampList; std::string VSSolutionFile; + std::vector<std::string> SourceFileExtensions; + std::vector<std::string> HeaderFileExtensions; bool ClearBuildSystem; bool DebugTryCompile; cmFileTimeComparison* FileComparison; diff --git a/Source/cmcmd.cxx b/Source/cmcmd.cxx index f44c77d..21b126b 100644 --- a/Source/cmcmd.cxx +++ b/Source/cmcmd.cxx @@ -35,8 +35,7 @@ #include <stdlib.h> // required for atoi #if defined(_WIN32) && defined(CMAKE_BUILD_WITH_CMAKE) -// defined in binexplib.cxx -bool DumpFile(const char* filename, FILE *fout); +#include "bindexplib.h" #endif void CMakeCommandUsage(const char* program) @@ -240,13 +239,16 @@ int cmcmd::ExecuteCMakeCommand(std::vector<std::string>& args) return 1; } std::string objfile; + bindexplib deffile; while(cmSystemTools::GetLineFromStream(fin, objfile)) { - if (!DumpFile(objfile.c_str(), fout)) + if( !deffile.AddObjectFile(objfile.c_str())) { return 1; } } + deffile.WriteFile(fout); + fclose(fout); return 0; } #endif @@ -765,15 +767,18 @@ int cmcmd::ExecuteCMakeCommand(std::vector<std::string>& args) startOutDir = cmSystemTools::CollapseFullPath(startOutDir); cm.SetHomeDirectory(homeDir); cm.SetHomeOutputDirectory(homeOutDir); + cm.GetCurrentSnapshot().SetDefaultDefinitions(); if(cmGlobalGenerator* ggd = cm.CreateGlobalGenerator(gen)) { cm.SetGlobalGenerator(ggd); cmState::Snapshot snapshot = cm.GetCurrentSnapshot(); + snapshot.GetDirectory().SetCurrentBinary + (cmSystemTools::GetCurrentWorkingDirectory()); + snapshot.GetDirectory().SetCurrentSource + (cmSystemTools::GetCurrentWorkingDirectory()); cmsys::auto_ptr<cmMakefile> mf(new cmMakefile(ggd, snapshot)); cmsys::auto_ptr<cmLocalGenerator> lgd( ggd->CreateLocalGenerator(mf.get())); - lgd->GetMakefile()->SetCurrentSourceDirectory(startDir); - lgd->GetMakefile()->SetCurrentBinaryDirectory(startOutDir); // Actually scan dependencies. return lgd->UpdateDependencies(depInfo.c_str(), @@ -1550,7 +1555,6 @@ bool cmVSLink::Parse(std::vector<std::string>::const_iterator argBeg, // pass it to the link command. this->ManifestFileRC = intDir + "/manifest.rc"; this->ManifestFileRes = intDir + "/manifest.res"; - this->LinkCommand.push_back(this->ManifestFileRes); } else if (this->UserManifests.empty()) { @@ -1658,6 +1662,9 @@ int cmVSLink::LinkIncremental() return -1; } + // Tell the linker to use our manifest compiled into a resource. + this->LinkCommand.push_back(this->ManifestFileRes); + // Run the link command (possibly generates intermediate manifest). if (!RunCommand("LINK Pass 1", this->LinkCommand, this->Verbose)) { diff --git a/Source/kwsys/CMakeLists.txt b/Source/kwsys/CMakeLists.txt index 84010d8..ce7f563 100644 --- a/Source/kwsys/CMakeLists.txt +++ b/Source/kwsys/CMakeLists.txt @@ -342,11 +342,6 @@ ENDIF() # capabilities and parent project's request. Enforce 0/1 as only # possible values for configuration into Configure.hxx. -IF(UNIX) - KWSYS_PLATFORM_CXX_TEST(KWSYS_STAT_HAS_ST_MTIM - "Checking whether struct stat has st_mtim member" DIRECT) -ENDIF() - # Check existence and uniqueness of long long and __int64. KWSYS_PLATFORM_CXX_TEST(KWSYS_CXX_HAS_LONG_LONG "Checking whether C++ compiler has 'long long'" DIRECT) @@ -511,12 +506,18 @@ IF(KWSYS_USE_SystemTools) "Checking whether CXX compiler has utimes" DIRECT) KWSYS_PLATFORM_CXX_TEST(KWSYS_CXX_HAS_UTIMENSAT "Checking whether CXX compiler has utimensat" DIRECT) + KWSYS_PLATFORM_CXX_TEST(KWSYS_CXX_STAT_HAS_ST_MTIM + "Checking whether CXX compiler struct stat has st_mtim member" DIRECT) + KWSYS_PLATFORM_CXX_TEST(KWSYS_CXX_STAT_HAS_ST_MTIMESPEC + "Checking whether CXX compiler struct stat has st_mtimespec member" DIRECT) SET_PROPERTY(SOURCE SystemTools.cxx APPEND PROPERTY COMPILE_DEFINITIONS KWSYS_CXX_HAS_SETENV=${KWSYS_CXX_HAS_SETENV} KWSYS_CXX_HAS_UNSETENV=${KWSYS_CXX_HAS_UNSETENV} KWSYS_CXX_HAS_ENVIRON_IN_STDLIB_H=${KWSYS_CXX_HAS_ENVIRON_IN_STDLIB_H} KWSYS_CXX_HAS_UTIMES=${KWSYS_CXX_HAS_UTIMES} KWSYS_CXX_HAS_UTIMENSAT=${KWSYS_CXX_HAS_UTIMENSAT} + KWSYS_CXX_STAT_HAS_ST_MTIM=${KWSYS_CXX_STAT_HAS_ST_MTIM} + KWSYS_CXX_STAT_HAS_ST_MTIMESPEC=${KWSYS_CXX_STAT_HAS_ST_MTIMESPEC} ) ENDIF() diff --git a/Source/kwsys/Configure.hxx.in b/Source/kwsys/Configure.hxx.in index 3faf862..ff8e49d 100644 --- a/Source/kwsys/Configure.hxx.in +++ b/Source/kwsys/Configure.hxx.in @@ -18,9 +18,6 @@ /* Whether wstring is available. */ #define @KWSYS_NAMESPACE@_STL_HAS_WSTRING @KWSYS_STL_HAS_WSTRING@ -/* Whether struct stat has the st_mtim member for high resolution times. */ -#define @KWSYS_NAMESPACE@_STAT_HAS_ST_MTIM @KWSYS_STAT_HAS_ST_MTIM@ - /* If building a C++ file in kwsys itself, give the source file access to the macros without a configured namespace. */ #if defined(KWSYS_NAMESPACE) @@ -28,7 +25,6 @@ # define kwsys @KWSYS_NAMESPACE@ # endif # define KWSYS_NAME_IS_KWSYS @KWSYS_NAMESPACE@_NAME_IS_KWSYS -# define KWSYS_STAT_HAS_ST_MTIM @KWSYS_NAMESPACE@_STAT_HAS_ST_MTIM # define KWSYS_STL_HAS_WSTRING @KWSYS_NAMESPACE@_STL_HAS_WSTRING #endif diff --git a/Source/kwsys/EncodingCXX.cxx b/Source/kwsys/EncodingCXX.cxx index 7d9b3e4..597d4bd 100644 --- a/Source/kwsys/EncodingCXX.cxx +++ b/Source/kwsys/EncodingCXX.cxx @@ -38,6 +38,7 @@ // Windows API. #if defined(_WIN32) # include <windows.h> +# include <shellapi.h> #endif namespace KWSYS_NAMESPACE diff --git a/Source/kwsys/SystemTools.cxx b/Source/kwsys/SystemTools.cxx index 262af27..da34eb9 100644 --- a/Source/kwsys/SystemTools.cxx +++ b/Source/kwsys/SystemTools.cxx @@ -1366,15 +1366,18 @@ bool SystemTools::Touch(const std::string& filename, bool create) struct timeval mtime; gettimeofday(&mtime, 0); # if KWSYS_CXX_HAS_UTIMES - struct timeval times[2] = - { -# if KWSYS_STAT_HAS_ST_MTIM - {st.st_atim.tv_sec, st.st_atim.tv_nsec/1000}, /* tv_sec, tv_usec */ + struct timeval atime; +# if KWSYS_CXX_STAT_HAS_ST_MTIM + atime.tv_sec = st.st_atim.tv_sec; + atime.tv_usec = st.st_atim.tv_nsec/1000; +# elif KWSYS_CXX_STAT_HAS_ST_MTIMESPEC + atime.tv_sec = st.st_atimespec.tv_sec; + atime.tv_usec = st.st_atimespec.tv_nsec/1000; # else - {st.st_atime, 0}, + atime.tv_sec = st.st_atime; + atime.tv_usec = 0; # endif - mtime - }; + struct timeval times[2] = { atime, mtime }; if(utimes(filename.c_str(), times) < 0) { return false; @@ -1408,7 +1411,7 @@ bool SystemTools::FileTimeCompare(const std::string& f1, { return false; } -# if KWSYS_STAT_HAS_ST_MTIM +# if KWSYS_CXX_STAT_HAS_ST_MTIM // Compare using nanosecond resolution. if(s1.st_mtim.tv_sec < s2.st_mtim.tv_sec) { @@ -1426,6 +1429,24 @@ bool SystemTools::FileTimeCompare(const std::string& f1, { *result = 1; } +# elif KWSYS_CXX_STAT_HAS_ST_MTIMESPEC + // Compare using nanosecond resolution. + if(s1.st_mtimespec.tv_sec < s2.st_mtimespec.tv_sec) + { + *result = -1; + } + else if(s1.st_mtimespec.tv_sec > s2.st_mtimespec.tv_sec) + { + *result = 1; + } + else if(s1.st_mtimespec.tv_nsec < s2.st_mtimespec.tv_nsec) + { + *result = -1; + } + else if(s1.st_mtimespec.tv_nsec > s2.st_mtimespec.tv_nsec) + { + *result = 1; + } # else // Compare using 1 second resolution. if(s1.st_mtime < s2.st_mtime) diff --git a/Source/kwsys/SystemTools.hxx.in b/Source/kwsys/SystemTools.hxx.in index d2d1d40..bba5a5c 100644 --- a/Source/kwsys/SystemTools.hxx.in +++ b/Source/kwsys/SystemTools.hxx.in @@ -703,13 +703,13 @@ public: /** * Create a symbolic link if the platform supports it. Returns whether - * creation succeded. + * creation succeeded. */ static bool CreateSymlink(const std::string& origName, const std::string& newName); /** * Read the contents of a symbolic link. Returns whether reading - * succeded. + * succeeded. */ static bool ReadSymlink(const std::string& newName, std::string& origName); diff --git a/Source/kwsys/Terminal.c b/Source/kwsys/Terminal.c index d13f79a..a8abb6c 100644 --- a/Source/kwsys/Terminal.c +++ b/Source/kwsys/Terminal.c @@ -184,14 +184,25 @@ static const char* kwsysTerminalVT100Names[] = static int kwsysTerminalStreamIsVT100(FILE* stream, int default_vt100, int default_tty) { + /* Force color according to http://bixense.com/clicolors/ convention. */ + { + const char* clicolor_force = getenv("CLICOLOR_FORCE"); + if (clicolor_force && *clicolor_force && strcmp(clicolor_force, "0") != 0) + { + return 1; + } + } + /* If running inside emacs the terminal is not VT100. Some emacs seem to claim the TERM is xterm even though they do not support VT100 escapes. */ + { const char* emacs = getenv("EMACS"); if(emacs && *emacs == 't') { return 0; } + } /* Check for a valid terminal. */ if(!default_vt100) diff --git a/Source/kwsys/kwsysPlatformTestsCXX.cxx b/Source/kwsys/kwsysPlatformTestsCXX.cxx index 94579b3..9626937 100644 --- a/Source/kwsys/kwsysPlatformTestsCXX.cxx +++ b/Source/kwsys/kwsysPlatformTestsCXX.cxx @@ -32,7 +32,7 @@ int main() } #endif -#ifdef TEST_KWSYS_STAT_HAS_ST_MTIM +#ifdef TEST_KWSYS_CXX_STAT_HAS_ST_MTIM #include <sys/types.h> #include <sys/stat.h> #include <unistd.h> @@ -45,6 +45,19 @@ int main() } #endif +#ifdef TEST_KWSYS_CXX_STAT_HAS_ST_MTIMESPEC +#include <sys/types.h> +#include <sys/stat.h> +#include <unistd.h> +int main() +{ + struct stat stat1; + (void)stat1.st_mtimespec.tv_sec; + (void)stat1.st_mtimespec.tv_nsec; + return 0; +} +#endif + #ifdef TEST_KWSYS_CXX_SAME_LONG_AND___INT64 void function(long**) {} int main() |