diff options
Diffstat (limited to 'Source')
27 files changed, 1296 insertions, 822 deletions
diff --git a/Source/CMakeLists.txt b/Source/CMakeLists.txt index bbfaf53..a707b55 100644 --- a/Source/CMakeLists.txt +++ b/Source/CMakeLists.txt @@ -159,6 +159,12 @@ IF(BUILD_TESTING) ADD_TEST(DumpDocumentation ${EXECUTABLE_OUTPUT_PATH}/DumpDocumentation --all-for-coverage) + ADD_TEST(CustomCommand ${EXECUTABLE_OUTPUT_PATH}/cmaketest + ${CMake_SOURCE_DIR}/Tests/CustomCommand + ${CMake_BINARY_DIR}/Tests/CustomCommand + CustomCommand + ${CMake_BINARY_DIR}/Tests/CustomCommand/bin) + ADD_TEST(SystemInformation ${EXECUTABLE_OUTPUT_PATH}/cmaketest ${CMake_SOURCE_DIR}/Tests/SystemInformation ${CMake_BINARY_DIR}/Tests/SystemInformation diff --git a/Source/cmAddCustomCommandCommand.cxx b/Source/cmAddCustomCommandCommand.cxx index a0a017d..d1de845 100644 --- a/Source/cmAddCustomCommandCommand.cxx +++ b/Source/cmAddCustomCommandCommand.cxx @@ -15,14 +15,14 @@ =========================================================================*/ #include "cmAddCustomCommandCommand.h" - +#include "cmTarget.h" // cmAddCustomCommandCommand bool cmAddCustomCommandCommand::InitialPass(std::vector<std::string> const& args) { /* Let's complain at the end of this function about the lack of a particular - arg. For the moment, let's say that COMMAND, TARGET are always - required. + arg. For the moment, let's say that COMMAND, and either TARGET or SOURCE + are required. */ if (args.size() < 4) { @@ -30,15 +30,19 @@ bool cmAddCustomCommandCommand::InitialPass(std::vector<std::string> const& args return false; } - std::string source, command, target, comment; + std::string source, command, target, comment, output, main_dependency; std::vector<std::string> command_args, depends, outputs; + cmTarget::CustomCommandType cctype = cmTarget::POST_BUILD; + enum tdoing { doing_source, doing_command, doing_target, doing_args, doing_depends, + doing_main_dependency, + doing_output, doing_outputs, doing_comment, doing_nothing @@ -58,6 +62,18 @@ bool cmAddCustomCommandCommand::InitialPass(std::vector<std::string> const& args { doing = doing_command; } + else if(copy == "PRE_BUILD") + { + cctype = cmTarget::PRE_BUILD; + } + else if(copy == "PRE_LINK") + { + cctype = cmTarget::PRE_LINK; + } + else if(copy == "POST_BUILD") + { + cctype = cmTarget::POST_BUILD; + } else if(copy == "TARGET") { doing = doing_target; @@ -74,6 +90,14 @@ bool cmAddCustomCommandCommand::InitialPass(std::vector<std::string> const& args { doing = doing_outputs; } + else if (copy == "OUTPUT") + { + doing = doing_output; + } + else if (copy == "MAIN_DEPENDENCY") + { + doing = doing_main_dependency; + } else if (copy == "COMMENT") { doing = doing_comment; @@ -85,6 +109,12 @@ bool cmAddCustomCommandCommand::InitialPass(std::vector<std::string> const& args case doing_source: source = copy; break; + case doing_output: + output = copy; + break; + case doing_main_dependency: + main_dependency = copy; + break; case doing_command: command = copy; break; @@ -114,21 +144,36 @@ bool cmAddCustomCommandCommand::InitialPass(std::vector<std::string> const& args For the moment, let's say that COMMAND, TARGET are always required. */ - - if(target.empty()) + if (output.empty() && target.empty()) { - this->SetError("Wrong syntax. Empty TARGET."); + this->SetError("Wrong syntax. A TARGET or OUTPUT must be specified."); return false; } + + // If source is empty, use the target + if(source.empty() && output.empty()) + { + m_Makefile->AddCustomCommandToTarget(target.c_str(), + command.c_str(), + command_args, + cctype, + comment.c_str()); + return true; + } - // If source is empty, use target as source, so that this command - // can be used to just attach a commmand to a target - - if(source.empty()) + // If target is empty, use the output + if(target.empty()) { - source = target; + m_Makefile->AddCustomCommandToOutput(output.c_str(), + command.c_str(), + command_args, + main_dependency.c_str(), + depends, + comment.c_str()); + return true; } + // otherwise backwards compatiblity mode m_Makefile->AddCustomCommand(source.c_str(), command.c_str(), command_args, diff --git a/Source/cmAddCustomCommandCommand.h b/Source/cmAddCustomCommandCommand.h index fe46f0e..218b676 100644 --- a/Source/cmAddCustomCommandCommand.h +++ b/Source/cmAddCustomCommandCommand.h @@ -86,42 +86,69 @@ public: virtual const char* GetFullDocumentation() { return - " ADD_CUSTOM_COMMAND(TARGET target\n" - " [SOURCE source]\n" - " [COMMAND command]\n" + "There are two main signatures for ADD_CUSTOM_COMMAND " + "The first signature is for adding a custom command " + "to a source file.\n" + " ADD_CUSTOM_COMMAND(OUTPUT result\n" + " COMMAND command\n" " [ARGS [args...]]\n" + " [MAIN_DEPENDENCY depend]\n" " [DEPENDS [depends...]]\n" - " [OUTPUTS [outputs...]]\n" " [COMMENT comment])\n" "This defines a new command that can be executed during the build " "process. In makefile terms this creates a new target in the " "following form:\n" - " OUTPUT1: SOURCE DEPENDS\n" - " COMAND ARGS\n" - " OUTPUT2: SOURCE DEPENDS\n" - " COMAND ARGS\n" - "The TARGET must be specified, but it is not the make target of the " - "build rule. It is the target (library, executable, or custom target) " - "that will use the output generated from this rule. This is necessary " - "to choose a project file in which to generate the rule for Visual " - "Studio.\n" - "Example of usage:\n" - " ADD_CUSTOM_COMMAND(\n" - " TARGET tiff\n" - " SOURCE ${TIFF_FAX_EXE}\n" - " COMMAND ${TIFF_FAX_EXE}\n" - " ARGS -c const ${TIFF_BINARY_DIR}/tif_fax3sm.c\n" - " OUTPUTS ${TIFF_BINARY_DIR}/tif_fax3sm.c\n" - " )\n" - "This will create custom target which will generate file tif_fax3sm.c " - "using command ${TIFF_FAX_EXE}. The rule will be executed as part of " - "building the tiff library because it includes tif_fax3sm.c as a " - "source file with the GENERATED property."; + " OUTPUT: MAIN_DEPENDENCY DEPENDS\n" + " COMMAND ARGS\n" + "\n" + "The second signature adds a custom command to a target " + "such as a library or executable. This is useful for " + "performing an operation before or after building the target " + "\n" + " ADD_CUSTOM_COMMAND(TARGET target\n" + " PRE_BUILD | PRE_LINK | POST_BUILD\n" + " COMMAND command\n" + " [ARGS [args...]]\n" + " [COMMENT comment])\n" + "This defines a new command that will be associated with " + "building the specified target. When the command will " + "happen is determined by whether you specify\n" + "PRE_BUILD - run before all other dependencies\n" + "PRE_LINK - run after other dependencies\n" + "POST_BUILD - run after the target has been built\n"; } cmTypeMacro(cmAddCustomCommandCommand, cmCommand); }; +/* + +target: normal depends + pre rules + normal rules + post rules + +output1: source other depends + rule + +output2: source other dpeends + rule + + +another option is + +output1: depends + rule + +output2: depends + rule + + + +use case1 - an executable that depending on args create diff output files + +*/ + #endif diff --git a/Source/cmAddCustomTargetCommand.cxx b/Source/cmAddCustomTargetCommand.cxx index 77ab3ef..8ab470c 100644 --- a/Source/cmAddCustomTargetCommand.cxx +++ b/Source/cmAddCustomTargetCommand.cxx @@ -45,14 +45,25 @@ bool cmAddCustomTargetCommand::InitialPass(std::vector<std::string> const& args) command = *s; ++s; } - for (;s != args.end(); ++s) + for (;s != args.end() && *s != "DEPENDS"; ++s) { arguments += cmSystemTools::EscapeSpaces(s->c_str()); arguments += " "; } + std::vector<std::string> depends; + // skip depends keyword + if (s != args.end()) + { + ++s; + } + while (s != args.end()) + { + depends.push_back(*s); + ++s; + } m_Makefile->AddUtilityCommand(args[0].c_str(), command.c_str(), - arguments.c_str(), all); + arguments.c_str(), all, depends); return true; } diff --git a/Source/cmAddCustomTargetCommand.h b/Source/cmAddCustomTargetCommand.h index 37f8537..778cc73 100644 --- a/Source/cmAddCustomTargetCommand.h +++ b/Source/cmAddCustomTargetCommand.h @@ -64,7 +64,8 @@ public: virtual const char* GetFullDocumentation() { return - " ADD_CUSTOM_TARGET(Name [ALL] [ command arg arg arg ... ])\n" + " ADD_CUSTOM_TARGET(Name [ALL] [ command arg arg arg ... ] " + " [DEPENDS depend depend depend ... ])\n" "Adds a target with the given name that executes the given command " "every time the target is built. If the ALL option is specified " "it indicates that this target should be added to the default build " diff --git a/Source/cmCPluginAPI.cxx b/Source/cmCPluginAPI.cxx index 4bec426..90be276 100644 --- a/Source/cmCPluginAPI.cxx +++ b/Source/cmCPluginAPI.cxx @@ -239,6 +239,56 @@ void cmAddCustomCommand(void *arg, const char* source, mf->AddCustomCommand(source, command, args2, depends2, outputs2, target); } +void cmAddCustomCommandToOutput(void *arg, const char* output, + const char* command, + int numArgs, const char **args, + const char* main_dependency, + int numDepends, const char **depends) +{ + cmMakefile *mf = static_cast<cmMakefile *>(arg); + int i; + std::vector<std::string> args2; + for (i = 0; i < numArgs; ++i) + { + args2.push_back(args[i]); + } + std::vector<std::string> depends2; + for (i = 0; i < numDepends; ++i) + { + depends2.push_back(depends[i]); + } + mf->AddCustomCommandToOutput(output, command, args2, main_dependency, + depends2); +} + +void cmAddCustomCommandToTarget(void *arg, const char* target, + const char* command, + int numArgs, const char **args, + int commandType) +{ + cmMakefile *mf = static_cast<cmMakefile *>(arg); + int i; + std::vector<std::string> args2; + for (i = 0; i < numArgs; ++i) + { + args2.push_back(args[i]); + } + switch (commandType) + { + case CM_PRE_BUILD: + mf->AddCustomCommandToTarget(target, command, args2, + cmTarget::PRE_BUILD); + break; + case CM_PRE_LINK: + mf->AddCustomCommandToTarget(target, command, args2, + cmTarget::PRE_LINK); + break; + case CM_POST_BUILD: + mf->AddCustomCommandToTarget(target, command, args2, + cmTarget::POST_BUILD); + break; + } +} void cmAddLinkLibraryForTarget(void *arg, const char *tgt, const char*value, int libtype) @@ -546,5 +596,8 @@ cmCAPI cmStaticCAPI = cmGetFilenamePath, cmRemoveFile, cmFree, + + cmAddCustomCommandToOutput, + cmAddCustomCommandToTarget, }; diff --git a/Source/cmCPluginAPI.h b/Source/cmCPluginAPI.h index da1f6f3..311e6ab 100644 --- a/Source/cmCPluginAPI.h +++ b/Source/cmCPluginAPI.h @@ -145,6 +145,19 @@ typedef struct void (*RemoveFile)(const char *f1); void (*Free)(void *); + /*========================================================================= + The following are new functions added after 1.6 + =========================================================================*/ + void (*AddCustomCommandToOutput) (void *mf, const char* output, + const char* command, + int numArgs, const char **args, + const char* main_dependency, + int numDepends, const char **depends); + void (*AddCustomCommandToTarget) (void *mf, const char* target, + const char* command, + int numArgs, const char **args, + int commandType); + /* this is the end of the C function stub API structure */ } cmCAPI; @@ -176,6 +189,12 @@ define the different types of compiles a library may be #define CM_LIBRARY_DEBUG 1 #define CM_LIBRARY_OPTIMIZED 2 +/*========================================================================= +define the different types of custom commands for a target +=========================================================================*/ +#define CM_PRE_BUILD 0 +#define CM_PRE_LINK 1 +#define CM_POST_BUILD 2 /*========================================================================= Finally we define the key data structures and function prototypes diff --git a/Source/cmCustomCommand.cxx b/Source/cmCustomCommand.cxx index d8fafe4..378505e 100644 --- a/Source/cmCustomCommand.cxx +++ b/Source/cmCustomCommand.cxx @@ -20,47 +20,48 @@ /** * The constructor */ -cmCustomCommand::cmCustomCommand(const char *src, const char *command, +cmCustomCommand::cmCustomCommand(const char *command, const char* arguments, std::vector<std::string> dep, - std::vector<std::string> out): - m_Source(src), + const char *out): m_Command(command), m_Arguments(arguments), - m_Depends(dep), - m_Outputs(out) + m_Depends(dep) { + if (out) + { + m_Output = out; + } } +cmCustomCommand::cmCustomCommand(const char *command, + const char* arguments): + m_Command(command), + m_Arguments(arguments) +{ +} /** * Copy constructor. */ cmCustomCommand::cmCustomCommand(const cmCustomCommand& r): - m_Source(r.m_Source), m_Command(r.m_Command), m_Arguments(r.m_Arguments), m_Comment(r.m_Comment), m_Depends(r.m_Depends), - m_Outputs(r.m_Outputs) + m_Output(r.m_Output) { } void cmCustomCommand::ExpandVariables(const cmMakefile &mf) { - mf.ExpandVariablesInString(m_Source); mf.ExpandVariablesInString(m_Command); mf.ExpandVariablesInString(m_Arguments); + mf.ExpandVariablesInString(m_Output); for (std::vector<std::string>::iterator i = m_Depends.begin(); i != m_Depends.end(); ++i) { mf.ExpandVariablesInString(*i); } - for (std::vector<std::string>::iterator i = m_Outputs.begin(); - i != m_Outputs.end(); ++i) - { - mf.ExpandVariablesInString(*i); - } } - diff --git a/Source/cmCustomCommand.h b/Source/cmCustomCommand.h index 9085177..79206ac 100644 --- a/Source/cmCustomCommand.h +++ b/Source/cmCustomCommand.h @@ -28,10 +28,13 @@ class cmMakefile; class cmCustomCommand { public: - cmCustomCommand(const char *src, const char *command, + cmCustomCommand(const char *command, const char* arguments, std::vector<std::string> dep, - std::vector<std::string> out); + const char *out); + cmCustomCommand(const char *command, + const char* arguments); + cmCustomCommand() {}; cmCustomCommand(const cmCustomCommand& r); /** @@ -40,12 +43,6 @@ public: */ void ExpandVariables(const cmMakefile &); - /** - * Return the name of the source file. I'm not sure if this is a full path or not. - */ - std::string GetSourceName() const {return m_Source;} - void SetSourceName(const char *name) {m_Source = name;} - ///! Return the command to execute with arguments std::string GetCommandAndArguments() const {return m_Command + " " + m_Arguments;} @@ -54,7 +51,11 @@ public: std::string GetCommand() const {return m_Command;} void SetCommand(const char *cmd) {m_Command = cmd;} - ///! Return the command to execute + ///! Return the output + std::string GetOutput() const {return m_Output;} + void SetOutput(const char *cm) {m_Output = cm;} + + ///! Return the comment std::string GetComment() const {return m_Comment;} void SetComment(const char *cm) {m_Comment = cm;} @@ -68,19 +69,12 @@ public: const std::vector<std::string> &GetDepends() const {return m_Depends;} std::vector<std::string> &GetDepends() {return m_Depends;} - /** - * Return the vector that holds the list of outputs of this command - */ - const std::vector<std::string> &GetOutputs() const {return m_Outputs;} - std::vector<std::string> &GetOutputs() {return m_Outputs;} - private: - std::string m_Source; std::string m_Command; std::string m_Arguments; std::string m_Comment; + std::string m_Output; std::vector<std::string> m_Depends; - std::vector<std::string> m_Outputs; }; diff --git a/Source/cmGlobalVisualStudio6Generator.cxx b/Source/cmGlobalVisualStudio6Generator.cxx index 0a204cf..2189679 100644 --- a/Source/cmGlobalVisualStudio6Generator.cxx +++ b/Source/cmGlobalVisualStudio6Generator.cxx @@ -146,8 +146,9 @@ void cmGlobalVisualStudio6Generator::Generate() { // add a special target that depends on ALL projects for easy build // of Debug only + std::vector<std::string> srcs; m_LocalGenerators[0]->GetMakefile()-> - AddUtilityCommand("ALL_BUILD", "echo","\"Build all projects\"",false); + AddUtilityCommand("ALL_BUILD", "echo","\"Build all projects\"",false,srcs); // add the Run Tests command this->SetupTests(); @@ -235,8 +236,9 @@ void cmGlobalVisualStudio6Generator::SetupTests() // If the file doesn't exist, then ENABLE_TESTING hasn't been run if (cmSystemTools::FileExists(fname.c_str())) { + std::vector<std::string> srcs; m_LocalGenerators[0]->GetMakefile()-> - AddUtilityCommand("RUN_TESTS", ctest.c_str(), "-D $(IntDir)",false); + AddUtilityCommand("RUN_TESTS", ctest.c_str(), "-D $(IntDir)",false,srcs); } } } @@ -310,12 +312,13 @@ void cmGlobalVisualStudio6Generator::WriteDSWFile(std::ostream& fout) // Write the project into the DSW file if (strncmp(l->first.c_str(), "INCLUDE_EXTERNAL_MSPROJECT", 26) == 0) { - cmCustomCommand cc = l->second.GetCustomCommands()[0]; + cmCustomCommand cc = l->second.GetPreLinkCommands()[0]; // dodgy use of the cmCustomCommand's members to store the // arguments from the INCLUDE_EXTERNAL_MSPROJECT command std::vector<std::string> stuff = cc.GetDepends(); - std::vector<std::string> depends = cc.GetOutputs(); + std::vector<std::string> depends; + depends.push_back(cc.GetOutput()); this->WriteExternalProject(fout, stuff[0].c_str(), stuff[1].c_str(), depends); ++si; } diff --git a/Source/cmGlobalVisualStudio71Generator.cxx b/Source/cmGlobalVisualStudio71Generator.cxx index d38c300..4564901 100644 --- a/Source/cmGlobalVisualStudio71Generator.cxx +++ b/Source/cmGlobalVisualStudio71Generator.cxx @@ -109,12 +109,13 @@ void cmGlobalVisualStudio71Generator::WriteSLNFile(std::ostream& fout) // Write the project into the SLN file if (strncmp(l->first.c_str(), "INCLUDE_EXTERNAL_MSPROJECT", 26) == 0) { - cmCustomCommand cc = l->second.GetCustomCommands()[0]; + cmCustomCommand cc = l->second.GetPreLinkCommands()[0]; // dodgy use of the cmCustomCommand's members to store the // arguments from the INCLUDE_EXTERNAL_MSPROJECT command std::vector<std::string> stuff = cc.GetDepends(); - std::vector<std::string> depends = cc.GetOutputs(); + std::vector<std::string> depends; + depends.push_back(cc.GetOutput()); this->WriteExternalProject(fout, stuff[0].c_str(), stuff[1].c_str(), depends); ++si; diff --git a/Source/cmGlobalVisualStudio7Generator.cxx b/Source/cmGlobalVisualStudio7Generator.cxx index 037e34a..c7d0324 100644 --- a/Source/cmGlobalVisualStudio7Generator.cxx +++ b/Source/cmGlobalVisualStudio7Generator.cxx @@ -145,8 +145,9 @@ void cmGlobalVisualStudio7Generator::SetupTests() // If the file doesn't exist, then ENABLE_TESTING hasn't been run if (cmSystemTools::FileExists(fname.c_str())) { + std::vector<std::string> srcs; m_LocalGenerators[0]->GetMakefile()-> - AddUtilityCommand("RUN_TESTS", ctest.c_str(), "-D $(IntDir)",false); + AddUtilityCommand("RUN_TESTS", ctest.c_str(), "-D $(IntDir)",false, srcs); } } } @@ -223,8 +224,9 @@ void cmGlobalVisualStudio7Generator::Generate() { // add a special target that depends on ALL projects for easy build // of Debug only + std::vector<std::string> srcs; m_LocalGenerators[0]->GetMakefile()-> - AddUtilityCommand("ALL_BUILD", "echo","\"Build all projects\"",false); + AddUtilityCommand("ALL_BUILD", "echo","\"Build all projects\"",false, srcs); // add the Run Tests command this->SetupTests(); @@ -340,12 +342,13 @@ void cmGlobalVisualStudio7Generator::WriteSLNFile(std::ostream& fout) // Write the project into the SLN file if (strncmp(l->first.c_str(), "INCLUDE_EXTERNAL_MSPROJECT", 26) == 0) { - cmCustomCommand cc = l->second.GetCustomCommands()[0]; + cmCustomCommand cc = l->second.GetPreLinkCommands()[0]; // dodgy use of the cmCustomCommand's members to store the // arguments from the INCLUDE_EXTERNAL_MSPROJECT command std::vector<std::string> stuff = cc.GetDepends(); - std::vector<std::string> depends = cc.GetOutputs(); + std::vector<std::string> depends; + depends.push_back(cc.GetOutput()); this->WriteExternalProject(fout, stuff[0].c_str(), stuff[1].c_str(), depends); ++si; diff --git a/Source/cmLocalUnixMakefileGenerator.cxx b/Source/cmLocalUnixMakefileGenerator.cxx index 5dab6a3..7b25c72 100644 --- a/Source/cmLocalUnixMakefileGenerator.cxx +++ b/Source/cmLocalUnixMakefileGenerator.cxx @@ -422,7 +422,8 @@ void cmLocalUnixMakefileGenerator::OutputTargetRules(std::ostream& fout) for(std::vector<cmSourceFile*>::iterator i = classes.begin(); i != classes.end(); i++) { - if(!(*i)->GetPropertyAsBool("HEADER_FILE_ONLY")) + if(!(*i)->GetPropertyAsBool("HEADER_FILE_ONLY") && + !(*i)->GetCustomCommand()) { std::string outExt( this->GetOutputExtension((*i)->GetSourceExtension().c_str())); @@ -439,7 +440,8 @@ void cmLocalUnixMakefileGenerator::OutputTargetRules(std::ostream& fout) for(std::vector<cmSourceFile*>::iterator i = classes.begin(); i != classes.end(); i++) { - if(!(*i)->GetPropertyAsBool("HEADER_FILE_ONLY")) + if(!(*i)->GetPropertyAsBool("HEADER_FILE_ONLY") && + !(*i)->GetCustomCommand()) { std::string outExt(this->GetOutputExtension((*i)->GetSourceExtension().c_str())); if(outExt.size()) @@ -676,31 +678,77 @@ void cmLocalUnixMakefileGenerator::OutputLinkLibraries(std::ostream& fout, } } +std::string cmLocalUnixMakefileGenerator::CreatePreBuildRules( + const cmTarget &target, const char* targetName) +{ + std::string customRuleCode = ""; + bool initNext = false; + for (std::vector<cmCustomCommand>::const_iterator cr = + target.GetPreBuildCommands().begin(); + cr != target.GetPreBuildCommands().end(); ++cr) + { + cmCustomCommand cc(*cr); + cc.ExpandVariables(*m_Makefile); + if(initNext) + { + customRuleCode += "\n\t"; + } + else + { + initNext = true; + } + std::string command = cmSystemTools::ConvertToOutputPath(cc.GetCommand().c_str()); + customRuleCode += command + " " + cc.GetArguments(); + } + return customRuleCode; +} -std::string cmLocalUnixMakefileGenerator::CreateTargetRules(const cmTarget &target, - const char* targetName) +std::string cmLocalUnixMakefileGenerator::CreatePreLinkRules( + const cmTarget &target, const char* targetName) { std::string customRuleCode = ""; bool initNext = false; for (std::vector<cmCustomCommand>::const_iterator cr = - target.GetCustomCommands().begin(); - cr != target.GetCustomCommands().end(); ++cr) + target.GetPreLinkCommands().begin(); + cr != target.GetPreLinkCommands().end(); ++cr) { cmCustomCommand cc(*cr); cc.ExpandVariables(*m_Makefile); - if (cc.GetSourceName() == targetName) + if(initNext) { - if(initNext) - { - customRuleCode += "\n\t"; - } - else - { - initNext = true; - } - std::string command = cmSystemTools::ConvertToOutputPath(cc.GetCommand().c_str()); - customRuleCode += command + " " + cc.GetArguments(); + customRuleCode += "\n\t"; + } + else + { + initNext = true; } + std::string command = cmSystemTools::ConvertToOutputPath(cc.GetCommand().c_str()); + customRuleCode += command + " " + cc.GetArguments(); + } + return customRuleCode; +} + +std::string cmLocalUnixMakefileGenerator::CreatePostBuildRules( + const cmTarget &target, const char* targetName) +{ + std::string customRuleCode = ""; + bool initNext = false; + for (std::vector<cmCustomCommand>::const_iterator cr = + target.GetPostBuildCommands().begin(); + cr != target.GetPostBuildCommands().end(); ++cr) + { + cmCustomCommand cc(*cr); + cc.ExpandVariables(*m_Makefile); + if(initNext) + { + customRuleCode += "\n\t"; + } + else + { + initNext = true; + } + std::string command = cmSystemTools::ConvertToOutputPath(cc.GetCommand().c_str()); + customRuleCode += command + " " + cc.GetArguments(); } return customRuleCode; } @@ -848,9 +896,21 @@ void cmLocalUnixMakefileGenerator::OutputLibraryRule(std::ostream& fout, // expand multi-command semi-colon separated lists // of commands into separate commands std::vector<std::string> commands; + // collect custom commands for this target and add them to the list + std::string customCommands = this->CreatePreBuildRules(t, name); + if(customCommands.size() > 0) + { + commands.push_back(customCommands); + } + // collect custom commands for this target and add them to the list + customCommands = this->CreatePreLinkRules(t, name); + if(customCommands.size() > 0) + { + commands.push_back(customCommands); + } cmSystemTools::ExpandList(rules, commands); // collect custom commands for this target and add them to the list - std::string customCommands = this->CreateTargetRules(t, name); + customCommands = this->CreatePostBuildRules(t, name); if(customCommands.size() > 0) { commands.push_back(customCommands); @@ -1072,8 +1132,18 @@ void cmLocalUnixMakefileGenerator::OutputExecutableRule(std::ostream& fout, std::string comment = "executable"; std::vector<std::string> commands; + std::string customCommands = this->CreatePreBuildRules(t, name); + if(customCommands.size() > 0) + { + commands.push_back(customCommands.c_str()); + } + customCommands = this->CreatePreLinkRules(t, name); + if(customCommands.size() > 0) + { + commands.push_back(customCommands.c_str()); + } cmSystemTools::ExpandList(rules, commands); - std::string customCommands = this->CreateTargetRules(t, name); + customCommands = this->CreatePostBuildRules(t, name); if(customCommands.size() > 0) { commands.push_back(customCommands.c_str()); @@ -1127,8 +1197,18 @@ void cmLocalUnixMakefileGenerator::OutputUtilityRule(std::ostream& fout, const char* name, const cmTarget &t) { - std::string customCommands = this->CreateTargetRules(t, name); const char* cc = 0; + std::string customCommands = this->CreatePreBuildRules(t, name); + std::string customCommands2 = this->CreatePreLinkRules(t, name); + if(customCommands2.size() > 0) + { + customCommands += customCommands2; + } + customCommands2 = this->CreatePostBuildRules(t, name); + if(customCommands2.size() > 0) + { + customCommands += customCommands2; + } if(customCommands.size() > 0) { cc = customCommands.c_str(); @@ -1136,7 +1216,7 @@ void cmLocalUnixMakefileGenerator::OutputUtilityRule(std::ostream& fout, std::string comment = "Utility"; std::string depends; std::string replaceVars; - const std::vector<cmCustomCommand> &ccs = t.GetCustomCommands(); + const std::vector<cmCustomCommand> &ccs = t.GetPostBuildCommands(); for(std::vector<cmCustomCommand>::const_iterator i = ccs.begin(); i != ccs.end(); ++i) { @@ -1513,6 +1593,17 @@ void cmLocalUnixMakefileGenerator::OutputExeDepend(std::ostream& fout, exepath += cmSystemTools::GetExecutableExtension(); fout << cmSystemTools::ConvertToOutputPath(exepath.c_str()) << " "; } + // if it isn't in the cache, it might still be a utility target + // so check for that + else + { + std::map<cmStdString, cmTarget>& targets = m_Makefile->GetTargets(); + if (targets.find(name) != targets.end()) + { + fout << name << " "; + } + } + } @@ -1707,9 +1798,6 @@ void cmLocalUnixMakefileGenerator::OutputSubDirectoryRules(std::ostream& fout) SubDirectories); } - - - // Output the depend information for all the classes // in the makefile. These would have been generated // by the class cmMakeDepend GenerateMakefile @@ -1821,126 +1909,76 @@ void cmLocalUnixMakefileGenerator::OutputCheckDepends(std::ostream& fout) // (tab) command... void cmLocalUnixMakefileGenerator::OutputCustomRules(std::ostream& fout) { - // We may be modifying the source groups temporarily, so make a copy. - std::vector<cmSourceGroup> sourceGroups = m_Makefile->GetSourceGroups(); + // we cannot provide multiple rules for a single output + // so we will keep track of outputs to make sure we don't write + // two rules. First found wins + std::set<std::string> processedOutputs; - const cmTargets &tgts = m_Makefile->GetTargets(); - for(cmTargets::const_iterator tgt = tgts.begin(); - tgt != tgts.end(); ++tgt) - { - // add any custom rules to the source groups - for (std::vector<cmCustomCommand>::const_iterator cr = - tgt->second.GetCustomCommands().begin(); - cr != tgt->second.GetCustomCommands().end(); ++cr) - { - // if the source for the custom command is the same name - // as the target, then to not create a rule in the makefile for - // the custom command, as the command will be fired when the other target - // is built. - if ( cr->GetSourceName().compare(tgt->first) !=0) - { - cmSourceGroup& sourceGroup = - m_Makefile->FindSourceGroup(cr->GetSourceName().c_str(), - sourceGroups); - cmCustomCommand cc(*cr); - cc.ExpandVariables(*m_Makefile); - sourceGroup.AddCustomCommand(cc); - } - } - } - - // Loop through every source group. - for(std::vector<cmSourceGroup>::const_iterator sg = - sourceGroups.begin(); sg != sourceGroups.end(); ++sg) + // first output all custom rules + const std::vector<cmSourceFile*>& sources = m_Makefile->GetSourceFiles(); + for(std::vector<cmSourceFile*>::const_iterator i = sources.begin(); + i != sources.end(); ++i) { - const cmSourceGroup::BuildRules& buildRules = sg->GetBuildRules(); - if(buildRules.empty()) - { continue; } - - std::string name = sg->GetName(); - if(name != "") + if ((*i)->GetCustomCommand()) { - fout << "# Start of source group \"" << name.c_str() << "\"\n"; - } - - // Loop through each source in the source group. - for(cmSourceGroup::BuildRules::const_iterator cc = - buildRules.begin(); cc != buildRules.end(); ++ cc) - { - std::string source = cc->first; - const cmSourceGroup::Commands& commands = cc->second.m_Commands; - // Loop through every command generating code from the current source. - for(cmSourceGroup::Commands::const_iterator c = commands.begin(); - c != commands.end(); ++c) + cmCustomCommand *c = (*i)->GetCustomCommand(); + // escape spaces and convert to native slashes path for + // the command + const char* comment = c->GetComment().c_str(); + std::string command = c->GetCommand(); + cmSystemTools::ReplaceString(command, "/./", "/"); + command = cmSystemTools::ConvertToOutputPath(command.c_str()); + command += " "; + // now add the arguments + command += c->GetArguments(); + std::string depends; + // Collect out all the dependencies for this rule. + for(std::vector<std::string>::const_iterator d = + c->GetDepends().begin(); + d != c->GetDepends().end(); ++d) { - // escape spaces and convert to native slashes path for - // the command - const char* comment = c->second.m_Comment.c_str(); - std::string command = c->second.m_Command; - cmSystemTools::ReplaceString(command, "/./", "/"); - command = cmSystemTools::ConvertToOutputPath(command.c_str()); - command += " "; - // now add the arguments - command += c->second.m_Arguments; - const cmSourceGroup::CommandFiles& commandFiles = c->second; - // if the command has no outputs, then it is a utility command - // with no outputs - if(commandFiles.m_Outputs.size() == 0) - { - std::string depends; - // collect out all the dependencies for this rule. - for(std::set<std::string>::const_iterator d = - commandFiles.m_Depends.begin(); - d != commandFiles.m_Depends.end(); ++d) - { - std::string dep = *d; - cmSystemTools::ReplaceString(dep, "/./", "/"); - cmSystemTools::ReplaceString(dep, "/$(IntDir)/", "/"); - dep = cmSystemTools::ConvertToOutputPath(dep.c_str()); - depends += " "; - depends += dep; - } - // output rule - this->OutputMakeRule(fout, - (*comment?comment:"Custom command"), - source.c_str(), - depends.c_str(), - command.c_str()); - } - // Write a rule for every output generated by this command. - for(std::set<std::string>::const_iterator output = - commandFiles.m_Outputs.begin(); - output != commandFiles.m_Outputs.end(); ++output) + std::string dep = *d; + m_Makefile->ExpandVariablesInString(dep); + + // watch for target dependencies, + std::string libPath = dep + "_CMAKE_PATH"; + const char* cacheValue = m_Makefile->GetDefinition(libPath.c_str()); + if (cacheValue) { - std::string src = cmSystemTools::ConvertToOutputPath(source.c_str()); - std::string depends; - depends += src; - // Collect out all the dependencies for this rule. - for(std::set<std::string>::const_iterator d = - commandFiles.m_Depends.begin(); - d != commandFiles.m_Depends.end(); ++d) + libPath = cacheValue; + if (m_Makefile->GetDefinition("EXECUTABLE_OUTPUT_PATH") && + m_Makefile->GetDefinition("EXECUTABLE_OUTPUT_PATH")[0] != '\0') { - std::string dep = *d; - cmSystemTools::ReplaceString(dep, "/./", "/"); - cmSystemTools::ReplaceString(dep, "/$(IntDir)/", "/"); - dep = cmSystemTools::ConvertToOutputPath(dep.c_str()); - depends += " "; - depends += dep; - } - // output rule - this->OutputMakeRule(fout, - (*comment?comment:"Custom command"), - output->c_str(), - depends.c_str(), - command.c_str()); + libPath = m_Makefile->GetDefinition("EXECUTABLE_OUTPUT_PATH"); + } + libPath += "/"; + libPath += dep; + libPath += cmSystemTools::GetExecutableExtension(); + dep = libPath; } + cmSystemTools::ReplaceString(dep, "/./", "/"); + cmSystemTools::ReplaceString(dep, "/$(IntDir)/", "/"); + dep = cmSystemTools::ConvertToOutputPath(dep.c_str()); + depends += " "; + depends += dep; + } + // output rule + if (processedOutputs.find(c->GetOutput()) == processedOutputs.end()) + { + this->OutputMakeRule(fout, + (*comment?comment:"Custom command"), + c->GetOutput().c_str(), + depends.c_str(), + command.c_str()); + processedOutputs.insert(c->GetOutput()); + } + else + { + cmSystemTools::Error("An output was found with multiple rules on how to build it for output: ", + c->GetOutput().c_str()); } } - if(name != "") - { - fout << "# End of source group \"" << name.c_str() << "\"\n\n"; - } - } + } } std::string @@ -2185,7 +2223,7 @@ void cmLocalUnixMakefileGenerator::OutputMakeRules(std::ostream& fout) // collect up all the sources std::string allsources; std::map<cmStdString, cmTarget>& targets = m_Makefile->GetTargets(); - for(std::map<cmStdString, cmTarget>::const_iterator target = targets.begin(); + for(std::map<cmStdString,cmTarget>::const_iterator target = targets.begin(); target != targets.end(); ++target) { // Iterate over every source for this target. @@ -2501,11 +2539,13 @@ void cmLocalUnixMakefileGenerator::OutputSourceObjectBuildRules(std::ostream& fo exportsDef = "-D"+ export_symbol; } // Iterate over every source for this target. - const std::vector<cmSourceFile*>& sources = target->second.GetSourceFiles(); + const std::vector<cmSourceFile*>& sources = + target->second.GetSourceFiles(); for(std::vector<cmSourceFile*>::const_iterator source = sources.begin(); source != sources.end(); ++source) { - if(!(*source)->GetPropertyAsBool("HEADER_FILE_ONLY")) + if(!(*source)->GetPropertyAsBool("HEADER_FILE_ONLY") && + !(*source)->GetCustomCommand()) { std::string shortName; std::string sourceName; @@ -2513,11 +2553,15 @@ void cmLocalUnixMakefileGenerator::OutputSourceObjectBuildRules(std::ostream& fo // directory, we want to use the relative path for the // filename of the object file. Otherwise, we will use just // the filename portion. - if((cmSystemTools::GetFilenamePath((*source)->GetFullPath()).find(m_Makefile->GetCurrentDirectory()) == 0) - || (cmSystemTools::GetFilenamePath((*source)->GetFullPath()).find(m_Makefile-> - GetCurrentOutputDirectory()) == 0)) + if((cmSystemTools::GetFilenamePath( + (*source)->GetFullPath()).find( + m_Makefile->GetCurrentDirectory()) == 0) + || (cmSystemTools::GetFilenamePath( + (*source)->GetFullPath()).find( + m_Makefile->GetCurrentOutputDirectory()) == 0)) { - sourceName = (*source)->GetSourceName()+"."+(*source)->GetSourceExtension(); + sourceName = (*source)->GetSourceName()+"."+ + (*source)->GetSourceExtension(); shortName = (*source)->GetSourceName(); // The path may be relative. See if a directory needs to be diff --git a/Source/cmLocalUnixMakefileGenerator.h b/Source/cmLocalUnixMakefileGenerator.h index f3ebd9e..b4fc54e 100644 --- a/Source/cmLocalUnixMakefileGenerator.h +++ b/Source/cmLocalUnixMakefileGenerator.h @@ -187,8 +187,12 @@ protected: ///! return true if the two paths are the same virtual bool SamePath(const char* path1, const char* path2); virtual std::string GetOutputExtension(const char* sourceExtension); - std::string CreateTargetRules(const cmTarget &target, - const char* targetName); + std::string CreatePreBuildRules(const cmTarget &target, + const char* targetName); + std::string CreatePreLinkRules(const cmTarget &target, + const char* targetName); + std::string CreatePostBuildRules(const cmTarget &target, + const char* targetName); virtual std::string CreateMakeVariable(const char* s, const char* s2); ///! if the OS is case insensitive then return a lower case of the path. diff --git a/Source/cmLocalVisualStudio6Generator.cxx b/Source/cmLocalVisualStudio6Generator.cxx index 5355e3a..5b001a2 100644 --- a/Source/cmLocalVisualStudio6Generator.cxx +++ b/Source/cmLocalVisualStudio6Generator.cxx @@ -20,6 +20,7 @@ #include "cmSystemTools.h" #include "cmSourceFile.h" #include "cmCacheManager.h" +#include <queue> cmLocalVisualStudio6Generator::cmLocalVisualStudio6Generator() { @@ -74,6 +75,9 @@ void cmLocalVisualStudio6Generator::OutputDSPFile() // clear project names m_CreatedProjectNames.clear(); + // expand vars for custom commands + m_Makefile->ExpandVariablesInCustomCommands(); + // build any targets cmTargets &tgts = m_Makefile->GetTargets(); for(cmTargets::iterator l = tgts.begin(); @@ -154,7 +158,7 @@ void cmLocalVisualStudio6Generator::CreateSingleDSP(const char *lname, cmTarget } -void cmLocalVisualStudio6Generator::AddDSPBuildRule(cmSourceGroup& sourceGroup) +void cmLocalVisualStudio6Generator::AddDSPBuildRule() { std::string dspname = *(m_CreatedProjectNames.end()-1); if(dspname == "ALL_BUILD") @@ -169,20 +173,28 @@ void cmLocalVisualStudio6Generator::AddDSPBuildRule(cmSourceGroup& sourceGroup) std::string dsprule = "${CMAKE_COMMAND}"; m_Makefile->ExpandVariablesInString(dsprule); dsprule = cmSystemTools::ConvertToOutputPath(dsprule.c_str()); - std::string args = makefileIn; - args += " -H"; + std::vector<std::string> argv; + argv.push_back(makefileIn); + makefileIn = m_Makefile->GetStartDirectory(); + makefileIn += "/"; + makefileIn += "CMakeLists.txt"; + std::string args; + args = "-H"; args += cmSystemTools::ConvertToOutputPath(m_Makefile->GetHomeDirectory()); - args += " -S"; + argv.push_back(args); + args = "-S"; args += cmSystemTools::ConvertToOutputPath(m_Makefile->GetStartDirectory()); - args += " -O"; + argv.push_back(args); + args = "-O"; args += cmSystemTools::ConvertToOutputPath(m_Makefile->GetStartOutputDirectory()); - args += " -B"; + argv.push_back(args); + args = "-B"; args += cmSystemTools::ConvertToOutputPath(m_Makefile->GetHomeOutputDirectory()); - m_Makefile->ExpandVariablesInString(args); + argv.push_back(args); std::string configFile = m_Makefile->GetDefinition("CMAKE_ROOT"); @@ -201,14 +213,9 @@ void cmLocalVisualStudio6Generator::AddDSPBuildRule(cmSourceGroup& sourceGroup) { listFiles.push_back(configFile); } - - std::vector<std::string> outputs; - outputs.push_back(dspname); - cmCustomCommand cc(makefileIn.c_str(), dsprule.c_str(), - args.c_str(), - listFiles, - outputs); - sourceGroup.AddCustomCommand(cc); + m_Makefile->AddCustomCommandToOutput(dspname.c_str(), dsprule.c_str(), + argv, makefileIn.c_str(), listFiles, + NULL, true); } @@ -219,8 +226,87 @@ void cmLocalVisualStudio6Generator::WriteDSPFile(std::ostream& fout, // We may be modifying the source groups temporarily, so make a copy. std::vector<cmSourceGroup> sourceGroups = m_Makefile->GetSourceGroups(); + // if we should add regen rule then... + const char *suppRegenRule = + m_Makefile->GetDefinition("CMAKE_SUPPRESS_REGENERATION"); + if (!cmSystemTools::IsOn(suppRegenRule)) + { + this->AddDSPBuildRule(); + } + // get the classes from the source lists then add them to the groups - std::vector<cmSourceFile*> classes = target.GetSourceFiles(); + std::vector<cmSourceFile*> & classes = target.GetSourceFiles(); + // use a deck to keep track of processed source files + std::queue<std::string> srcFilesToProcess; + std::string name; + for(std::vector<cmSourceFile*>::const_iterator i = classes.begin(); + i != classes.end(); ++i) + { + name = (*i)->GetSourceName(); + if ((*i)->GetSourceExtension() != "rule") + { + name += "."; + name += (*i)->GetSourceExtension(); + } + srcFilesToProcess.push(name); + } + name = libName; + name += ".dsp.cmake"; + srcFilesToProcess.push(name); + // add in the library depends for cusotm targets + if (target.GetType() == cmTarget::UTILITY) + { + cmCustomCommand &c = target.GetPostBuildCommands()[0]; + for (std::vector<std::string>::iterator i = c.GetDepends().begin(); + i != c.GetDepends().end(); ++i) + { + srcFilesToProcess.push(*i); + } + } + while (!srcFilesToProcess.empty()) + { + // is this source the output of a custom command + cmSourceFile* outsf = + m_Makefile->GetSourceFileWithOutput(srcFilesToProcess.front().c_str()); + if (outsf) + { + // is it not already in the target? + if (std::find(classes.begin(),classes.end(),outsf) == classes.end()) + { + // then add the source to this target and add it to the queue + classes.push_back(outsf); + std::string name = outsf->GetSourceName(); + if (outsf->GetSourceExtension() != "rule") + { + name += "."; + name += outsf->GetSourceExtension(); + } + srcFilesToProcess.push(name); + } + // add its dependencies to the list to check + unsigned int i; + for (i = 0; i < outsf->GetCustomCommand()->GetDepends().size(); ++i) + { + std::string dep = cmSystemTools::GetFilenameName( + outsf->GetCustomCommand()->GetDepends()[i]); + // watch for target dependencies, + std::string libPath = dep + "_CMAKE_PATH"; + const char* cacheValue = m_Makefile->GetDefinition(libPath.c_str()); + if (cacheValue) + { + // add the depend as a utility on the target + target.AddUtility(dep.c_str()); + } + else + { + srcFilesToProcess.push(dep); + } + } + } + // finished with this SF move to the next + srcFilesToProcess.pop(); + } + for(std::vector<cmSourceFile*>::iterator i = classes.begin(); i != classes.end(); i++) { @@ -231,49 +317,20 @@ void cmLocalVisualStudio6Generator::WriteDSPFile(std::ostream& fout, sourceGroup.AddSource(source.c_str(), *i); } - // add any custom rules to the source groups - for (std::vector<cmCustomCommand>::const_iterator cr = - target.GetCustomCommands().begin(); - cr != target.GetCustomCommands().end(); ++cr) - { - cmSourceGroup& sourceGroup = - m_Makefile->FindSourceGroup(cr->GetSourceName().c_str(), - sourceGroups); - cmCustomCommand cc(*cr); - cc.ExpandVariables(*m_Makefile); - sourceGroup.AddCustomCommand(cc); - } - // Write the DSP file's header. this->WriteDSPHeader(fout, libName, target, sourceGroups); - // if we should add regen rule then... - const char *suppRegenRule = - m_Makefile->GetDefinition("CMAKE_SUPPRESS_REGENERATION"); - - // Find the group in which the CMakeLists.txt source belongs, and add - // the rule to generate this DSP file. - if (!cmSystemTools::IsOn(suppRegenRule)) - { - for(std::vector<cmSourceGroup>::reverse_iterator sg = sourceGroups.rbegin(); - sg != sourceGroups.rend(); ++sg) - { - if(sg->Matches("CMakeLists.txt")) - { - this->AddDSPBuildRule(*sg); - break; - } - } - } - // Loop through every source group. for(std::vector<cmSourceGroup>::const_iterator sg = sourceGroups.begin(); sg != sourceGroups.end(); ++sg) { - const cmSourceGroup::BuildRules& buildRules = sg->GetBuildRules(); + const std::vector<const cmSourceFile *> &sourceFiles = + sg->GetSourceFiles(); // If the group is empty, don't write it at all. - if(buildRules.empty()) - { continue; } + if(sourceFiles.empty()) + { + continue; + } // If the group has a name, write the header. std::string name = sg->GetName(); @@ -282,37 +339,32 @@ void cmLocalVisualStudio6Generator::WriteDSPFile(std::ostream& fout, this->WriteDSPBeginGroup(fout, name.c_str(), ""); } - // Loop through each build rule in the source group. - for(cmSourceGroup::BuildRules::const_iterator cc = - buildRules.begin(); cc != buildRules.end(); ++ cc) + // Loop through each source in the source group. + for(std::vector<const cmSourceFile *>::const_iterator sf = + sourceFiles.begin(); sf != sourceFiles.end(); ++sf) { - std::string source = cc->first; - const cmSourceGroup::Commands& commands = cc->second.m_Commands; - std::vector<std::string> depends; + std::string source = (*sf)->GetFullPath(); + const cmCustomCommand *command = + (*sf)->GetCustomCommand(); std::string compileFlags; - if(cc->second.m_SourceFile) + std::vector<std::string> depends; + const char* cflags = (*sf)->GetProperty("COMPILE_FLAGS"); + if(cflags) { - // Check for extra compiler flags. - const char* cflags = cc->second.m_SourceFile->GetProperty("COMPILE_FLAGS"); - if(cflags) - { - compileFlags = cflags; - } - if(cmSystemTools::GetFileFormat( - cc->second.m_SourceFile->GetSourceExtension().c_str()) - == cmSystemTools::CXX_FILE_FORMAT) - { - // force a C++ file type - compileFlags += " /TP "; - } - - // Check for extra object-file dependencies. - const char* dependsValue = - cc->second.m_SourceFile->GetProperty("OBJECT_DEPENDS"); - if(dependsValue) - { - cmSystemTools::ExpandListArgument(dependsValue, depends); - } + compileFlags = cflags; + } + if(cmSystemTools::GetFileFormat((*sf)->GetSourceExtension().c_str()) + == cmSystemTools::CXX_FILE_FORMAT) + { + // force a C++ file type + compileFlags += " /TP "; + } + + // Check for extra object-file dependencies. + const char* dependsValue = (*sf)->GetProperty("OBJECT_DEPENDS"); + if(dependsValue) + { + cmSystemTools::ExpandListArgument(dependsValue, depends); } if (source != libName || target.GetType() == cmTarget::UTILITY) { @@ -334,18 +386,20 @@ void cmLocalVisualStudio6Generator::WriteDSPFile(std::ostream& fout, } fout << "\n"; } - if (!commands.empty()) + if (command) { - cmSourceGroup::CommandFiles totalCommand; std::string totalCommandStr; - totalCommandStr = this->CombineCommands(commands, totalCommand, - source.c_str()); - const char* comment = totalCommand.m_Comment.c_str(); + totalCommandStr = + cmSystemTools::ConvertToOutputPath(command->GetCommand().c_str()); + totalCommandStr += " "; + totalCommandStr += command->GetArguments(); + totalCommandStr += "\n"; + const char* comment = command->GetComment().c_str(); const char* flags = compileFlags.size() ? compileFlags.c_str(): 0; this->WriteCustomRule(fout, source.c_str(), totalCommandStr.c_str(), (*comment?comment:"Custom Rule"), - totalCommand.m_Depends, - totalCommand.m_Outputs, flags); + command->GetDepends(), + command->GetOutput().c_str(), flags); } else if(compileFlags.size()) { @@ -384,8 +438,8 @@ void cmLocalVisualStudio6Generator::WriteCustomRule(std::ostream& fout, const char* source, const char* command, const char* comment, - const std::set<std::string>& depends, - const std::set<std::string>& outputs, + const std::vector<std::string>& depends, + const char *output, const char* flags ) { @@ -406,7 +460,7 @@ void cmLocalVisualStudio6Generator::WriteCustomRule(std::ostream& fout, } // Write out the dependencies for the rule. fout << "USERDEP__HACK="; - for(std::set<std::string>::const_iterator d = depends.begin(); + for(std::vector<std::string>::const_iterator d = depends.begin(); d != depends.end(); ++d) { fout << "\\\n\t" << @@ -417,21 +471,16 @@ void cmLocalVisualStudio6Generator::WriteCustomRule(std::ostream& fout, fout << "# PROP Ignore_Default_Tool 1\n"; fout << "# Begin Custom Build - Building " << comment << " $(InputPath)\n\n"; - if(outputs.size() == 0) + if(output == 0) { fout << source << "_force : \"$(SOURCE)\" \"$(INTDIR)\" \"$(OUTDIR)\""; fout << command << "\n\n"; } // Write a rule for every output generated by this command. - for(std::set<std::string>::const_iterator output = outputs.begin(); - output != outputs.end(); ++output) - { - fout << cmSystemTools::ConvertToOutputPath(output->c_str()) - << " : \"$(SOURCE)\" \"$(INTDIR)\" \"$(OUTDIR)\""; - fout << command << "\n\n"; - } - + fout << cmSystemTools::ConvertToOutputPath(output) + << " : \"$(SOURCE)\" \"$(INTDIR)\" \"$(OUTDIR)\""; + fout << command << "\n\n"; fout << "# End Custom Build\n\n"; } @@ -544,46 +593,6 @@ void cmLocalVisualStudio6Generator::SetBuildType(BuildType b, } } -std::string -cmLocalVisualStudio6Generator::CombineCommands(const cmSourceGroup::Commands &commands, - cmSourceGroup::CommandFiles &totalCommand, - const char *source) - -{ - // Loop through every custom command generating code from the - // current source. - // build up the depends and outputs and commands - std::string totalCommandStr = ""; - std::string temp; - for(cmSourceGroup::Commands::const_iterator c = commands.begin(); - c != commands.end(); ++c) - { - totalCommandStr += "\n\t"; - temp= c->second.m_Command; - temp = cmSystemTools::ConvertToOutputPath(temp.c_str()); - totalCommandStr += temp; - totalCommandStr += " "; - totalCommandStr += c->second.m_Arguments; - totalCommand.Merge(c->second); - totalCommand.m_Comment = c->second.m_Comment.c_str(); - } - // Create a dummy file with the name of the source if it does - // not exist - if(totalCommand.m_Outputs.empty()) - { - std::string dummyFile = m_Makefile->GetStartOutputDirectory(); - dummyFile += "/"; - dummyFile += source; - if(!cmSystemTools::FileExists(dummyFile.c_str())) - { - std::ofstream fout(dummyFile.c_str()); - fout << "Dummy file created by cmake as unused source for utility command.\n"; - } - } - return totalCommandStr; -} - - // look for custom rules on a target and collect them together std::string cmLocalVisualStudio6Generator::CreateTargetRules(const cmTarget &target, @@ -591,39 +600,85 @@ cmLocalVisualStudio6Generator::CreateTargetRules(const cmTarget &target, { std::string customRuleCode = ""; - if (target.GetType() >= cmTarget::UTILITY) + if (target.GetType() > cmTarget::UTILITY) { return customRuleCode; } + + // are there any rules? + if (target.GetPreBuildCommands().size() + + target.GetPreLinkCommands().size() + + target.GetPostBuildCommands().size() == 0) + { + return customRuleCode; + } + + customRuleCode = "# Begin Special Build Tool\n"; - // Find the group in which the lix exe custom rules belong + // Do the PreBuild and PreLink (VS6 does not support both) bool init = false; for (std::vector<cmCustomCommand>::const_iterator cr = - target.GetCustomCommands().begin(); - cr != target.GetCustomCommands().end(); ++cr) + target.GetPreBuildCommands().begin(); + cr != target.GetPreBuildCommands().end(); ++cr) { cmCustomCommand cc(*cr); cc.ExpandVariables(*m_Makefile); - if (cc.GetSourceName() == libName) + if (!init) { - if (!init) - { - // header stuff - customRuleCode = "# Begin Special Build Tool\nPostBuild_Cmds="; - init = true; - } - else - { - customRuleCode += "\t"; - } - customRuleCode += cmSystemTools::ConvertToOutputPath(cc.GetCommand().c_str()) + " " + cc.GetArguments(); + // header stuff + customRuleCode = "PreLink_Cmds="; + init = true; + } + else + { + customRuleCode += "\t"; + } + customRuleCode += cmSystemTools::ConvertToOutputPath(cc.GetCommand().c_str()) + " " + cc.GetArguments(); + } + + for (std::vector<cmCustomCommand>::const_iterator cr = + target.GetPreLinkCommands().begin(); + cr != target.GetPreLinkCommands().end(); ++cr) + { + cmCustomCommand cc(*cr); + cc.ExpandVariables(*m_Makefile); + if (!init) + { + // header stuff + customRuleCode = "PreLink_Cmds="; + init = true; + } + else + { + customRuleCode += "\t"; } + customRuleCode += cmSystemTools::ConvertToOutputPath(cc.GetCommand().c_str()) + " " + cc.GetArguments(); } - if (init) + // do the post build rules + init = false; + for (std::vector<cmCustomCommand>::const_iterator cr = + target.GetPostBuildCommands().begin(); + cr != target.GetPostBuildCommands().end(); ++cr) { - customRuleCode += "\n# End Special Build Tool\n"; + cmCustomCommand cc(*cr); + cc.ExpandVariables(*m_Makefile); + if (!init) + { + // header stuff + customRuleCode = "PostBuild_Cmds="; + init = true; + } + else + { + customRuleCode += "\t"; + } + customRuleCode += + cmSystemTools::ConvertToOutputPath(cc.GetCommand().c_str()) + + " " + cc.GetArguments(); } + + customRuleCode += "\n# End Special Build Tool\n"; return customRuleCode; } diff --git a/Source/cmLocalVisualStudio6Generator.h b/Source/cmLocalVisualStudio6Generator.h index c3b2001..f4cee58 100644 --- a/Source/cmLocalVisualStudio6Generator.h +++ b/Source/cmLocalVisualStudio6Generator.h @@ -22,9 +22,8 @@ class cmMakeDepend; class cmTarget; class cmSourceFile; - -// please remove me.... Yuck -#include "cmSourceGroup.h" +class cmSourceGroup; +class cmCustomCommand; /** \class cmLocalVisualStudio6Generator * \brief Write a LocalUnix makefiles. @@ -84,21 +83,17 @@ private: const cmTarget &tgt, std::vector<cmSourceGroup> &sgs); void WriteDSPFooter(std::ostream& fout); - void AddDSPBuildRule(cmSourceGroup&); + void AddDSPBuildRule(); void WriteCustomRule(std::ostream& fout, const char* source, const char* command, const char* comment, - const std::set<std::string>& depends, - const std::set<std::string>& outputs, + const std::vector<std::string>& depends, + const char* output, const char* flags); std::string CreateTargetRules(const cmTarget &target, const char *libName); - std::string CombineCommands(const cmSourceGroup::Commands &commands, - cmSourceGroup::CommandFiles &totalCommand, - const char *source); - std::string m_IncludeOptions; std::vector<std::string> m_Configurations; }; diff --git a/Source/cmLocalVisualStudio7Generator.cxx b/Source/cmLocalVisualStudio7Generator.cxx index ee7225b..2aced52 100644 --- a/Source/cmLocalVisualStudio7Generator.cxx +++ b/Source/cmLocalVisualStudio7Generator.cxx @@ -21,6 +21,7 @@ #include "cmSourceFile.h" #include "cmCacheManager.h" #include "cmake.h" +#include <queue> cmLocalVisualStudio7Generator::cmLocalVisualStudio7Generator() { @@ -85,6 +86,9 @@ void cmLocalVisualStudio7Generator::OutputVCProjFile() // clear project names m_CreatedProjectNames.clear(); + // expand vars for custom commands + m_Makefile->ExpandVariablesInCustomCommands(); + // build any targets cmTargets &tgts = m_Makefile->GetTargets(); for(cmTargets::iterator l = tgts.begin(); @@ -127,7 +131,7 @@ void cmLocalVisualStudio7Generator::CreateSingleVCProj(const char *lname, cmTarg } -void cmLocalVisualStudio7Generator::AddVCProjBuildRule(cmSourceGroup& sourceGroup) +void cmLocalVisualStudio7Generator::AddVCProjBuildRule() { std::string dspname = *(m_CreatedProjectNames.end()-1); if(dspname == "ALL_BUILD") @@ -142,22 +146,29 @@ void cmLocalVisualStudio7Generator::AddVCProjBuildRule(cmSourceGroup& sourceGrou std::string dsprule = "${CMAKE_COMMAND}"; m_Makefile->ExpandVariablesInString(dsprule); dsprule = cmSystemTools::ConvertToOutputPath(dsprule.c_str()); - std::string args = makefileIn; - args += " -H"; + std::vector<std::string> argv; + argv.push_back(makefileIn); + makefileIn = m_Makefile->GetStartDirectory(); + makefileIn += "/"; + makefileIn += "CMakeLists.txt"; + std::string args; + args = "-H"; args += cmSystemTools::ConvertToOutputPath(m_Makefile->GetHomeDirectory()); - args += " -S"; - args += + argv.push_back(args); + args = "-S"; + args += cmSystemTools::ConvertToOutputPath(m_Makefile->GetStartDirectory()); - args += " -O"; + argv.push_back(args); + args = "-O"; args += cmSystemTools::ConvertToOutputPath(m_Makefile->GetStartOutputDirectory()); - args += " -B"; + argv.push_back(args); + args = "-B"; args += cmSystemTools::ConvertToOutputPath(m_Makefile->GetHomeOutputDirectory()); - args += ""; - m_Makefile->ExpandVariablesInString(args); - + argv.push_back(args); + std::string configFile = m_Makefile->GetDefinition("CMAKE_ROOT"); configFile += "/Templates/CMakeWindowsSystemConfig.cmake"; @@ -175,14 +186,9 @@ void cmLocalVisualStudio7Generator::AddVCProjBuildRule(cmSourceGroup& sourceGrou { listFiles.push_back(configFile); } - - std::vector<std::string> outputs; - outputs.push_back(dspname); - cmCustomCommand cc(makefileIn.c_str(), dsprule.c_str(), - args.c_str(), - listFiles, - outputs); - sourceGroup.AddCustomCommand(cc); + m_Makefile->AddCustomCommandToOutput(dspname.c_str(), dsprule.c_str(), + argv, makefileIn.c_str(), listFiles, + NULL, true); } @@ -359,10 +365,7 @@ void cmLocalVisualStudio7Generator::WriteConfiguration(std::ostream& fout, } fout << "\"\n/>\n"; fout << "\t\t\t<Tool\n\t\t\t\tName=\"VCMIDLTool\"/>\n"; - fout << "\t\t\t<Tool\n\t\t\t\tName=\"VCPostBuildEventTool\""; this->OutputTargetRules(fout, target, libName); - fout << "/>\n"; - fout << "\t\t\t<Tool\n\t\t\t\tName=\"VCPreBuildEventTool\"/>\n"; this->OutputBuildTool(fout, configName, libName, target); fout << "\t\t</Configuration>\n"; } @@ -635,18 +638,104 @@ void cmLocalVisualStudio7Generator::OutputDefineFlags(std::ostream& fout) } void cmLocalVisualStudio7Generator::WriteVCProjFile(std::ostream& fout, - const char *libName, - cmTarget &target) + const char *libName, + cmTarget &target) { // get the configurations std::vector<std::string> *configs = - static_cast<cmGlobalVisualStudio7Generator *>(m_GlobalGenerator)->GetConfigurations(); + static_cast<cmGlobalVisualStudio7Generator *> + (m_GlobalGenerator)->GetConfigurations(); + // if we should add regen rule then... + const char *suppRegenRule = + m_Makefile->GetDefinition("CMAKE_SUPPRESS_REGENERATION"); + if (!cmSystemTools::IsOn(suppRegenRule)) + { + this->AddVCProjBuildRule(); + } + // We may be modifying the source groups temporarily, so make a copy. std::vector<cmSourceGroup> sourceGroups = m_Makefile->GetSourceGroups(); // get the classes from the source lists then add them to the groups - std::vector<cmSourceFile*> const& classes = target.GetSourceFiles(); + std::vector<cmSourceFile*> & classes = target.GetSourceFiles(); + // use a deck to keep track of processed source files + std::queue<std::string> srcFilesToProcess; + std::string name; + for(std::vector<cmSourceFile*>::const_iterator i = classes.begin(); + i != classes.end(); ++i) + { + std::string name = (*i)->GetSourceName(); + if ((*i)->GetSourceExtension() != "rule") + { + name += "."; + name += (*i)->GetSourceExtension(); + } + srcFilesToProcess.push(name); + } + // add in the project file itself + name = libName; + name += ".vcproj.cmake"; + srcFilesToProcess.push(name); + // add in the library depends for cusotm targets + if (target.GetType() == cmTarget::UTILITY) + { + cmCustomCommand &c = target.GetPostBuildCommands()[0]; + for (std::vector<std::string>::iterator i = c.GetDepends().begin(); + i != c.GetDepends().end(); ++i) + { + srcFilesToProcess.push(*i); + } + } + while (!srcFilesToProcess.empty()) + { + // is this source the output of a custom command + cmSourceFile* outsf = + m_Makefile->GetSourceFileWithOutput(srcFilesToProcess.front().c_str()); + if (outsf) + { + // is it not already in the target? + if (std::find(classes.begin(),classes.end(),outsf) == classes.end()) + { + // then add the source to this target and add it to the queue + classes.push_back(outsf); + std::string name = outsf->GetSourceName(); + if (outsf->GetSourceExtension() != "rule") + { + name += "."; + name += outsf->GetSourceExtension(); + } + srcFilesToProcess.push(name); + } + // add its dependencies to the list to check + unsigned int i; + for (i = 0; i < outsf->GetCustomCommand()->GetDepends().size(); ++i) + { + std::string dep = cmSystemTools::GetFilenameName( + outsf->GetCustomCommand()->GetDepends()[i]); + if (cmSystemTools::GetFilenameLastExtension(dep) == ".exe") + { + dep = cmSystemTools::GetFilenameWithoutLastExtension(dep); + } + // watch for target dependencies, + std::string libPath = dep + "_CMAKE_PATH"; + const char* cacheValue = m_Makefile->GetDefinition(libPath.c_str()); + if (cacheValue) + { + // add the depend as a utility on the target + target.AddUtility(dep.c_str()); + } + else + { + srcFilesToProcess.push(dep); + } + } + } + // finished with this SF move to the next + srcFilesToProcess.pop(); + } + + // get the classes from the source lists then add them to the groups for(std::vector<cmSourceFile*>::const_iterator i = classes.begin(); i != classes.end(); i++) { @@ -656,23 +745,9 @@ void cmLocalVisualStudio7Generator::WriteVCProjFile(std::ostream& fout, { m_ModuleDefinitionFile = (*i)->GetFullPath(); } - - cmSourceGroup& sourceGroup = m_Makefile->FindSourceGroup(source.c_str(), - sourceGroups); - sourceGroup.AddSource(source.c_str(), *i); - } - - // add any custom rules to the source groups - for (std::vector<cmCustomCommand>::const_iterator cr = - target.GetCustomCommands().begin(); - cr != target.GetCustomCommands().end(); ++cr) - { cmSourceGroup& sourceGroup = - m_Makefile->FindSourceGroup(cr->GetSourceName().c_str(), - sourceGroups); - cmCustomCommand cc(*cr); - cc.ExpandVariables(*m_Makefile); - sourceGroup.AddCustomCommand(cc); + m_Makefile->FindSourceGroup(source.c_str(), sourceGroups); + sourceGroup.AddSource(source.c_str(), *i); } // open the project @@ -682,34 +757,18 @@ void cmLocalVisualStudio7Generator::WriteVCProjFile(std::ostream& fout, fout << "\t<Files>\n"; - // if we should add regen rule then... - const char *suppRegenRule = - m_Makefile->GetDefinition("CMAKE_SUPPRESS_REGENERATION"); - - // Find the group in which the CMakeLists.txt source belongs, and add - // the rule to generate this VCProj file. - if (!cmSystemTools::IsOn(suppRegenRule)) - { - for(std::vector<cmSourceGroup>::reverse_iterator sg = - sourceGroups.rbegin(); - sg != sourceGroups.rend(); ++sg) - { - if(sg->Matches("CMakeLists.txt")) - { - this->AddVCProjBuildRule(*sg); - break; - } - } - } // Loop through every source group. for(std::vector<cmSourceGroup>::const_iterator sg = sourceGroups.begin(); sg != sourceGroups.end(); ++sg) { - const cmSourceGroup::BuildRules& buildRules = sg->GetBuildRules(); + const std::vector<const cmSourceFile *> &sourceFiles = + sg->GetSourceFiles(); // If the group is empty, don't write it at all. - if(buildRules.empty()) - { continue; } + if(sourceFiles.empty()) + { + continue; + } // If the group has a name, write the header. std::string name = sg->GetName(); @@ -718,45 +777,41 @@ void cmLocalVisualStudio7Generator::WriteVCProjFile(std::ostream& fout, this->WriteVCProjBeginGroup(fout, name.c_str(), ""); } - // Loop through each build rule in the source group. - for(cmSourceGroup::BuildRules::const_iterator cc = - buildRules.begin(); cc != buildRules.end(); ++ cc) + // Loop through each source in the source group. + for(std::vector<const cmSourceFile *>::const_iterator sf = + sourceFiles.begin(); sf != sourceFiles.end(); ++sf) { - std::string source = cc->first; - const cmSourceGroup::Commands& commands = cc->second.m_Commands; + std::string source = (*sf)->GetFullPath(); + const cmCustomCommand *command = (*sf)->GetCustomCommand(); std::string compileFlags; std::string additionalDeps; - if(cc->second.m_SourceFile) + + // Check for extra compiler flags. + const char* cflags = (*sf)->GetProperty("COMPILE_FLAGS"); + if(cflags) { - // Check for extra compiler flags. - const char* cflags = cc->second.m_SourceFile->GetProperty("COMPILE_FLAGS"); - if(cflags) - { - compileFlags = cc->second.m_SourceFile->GetProperty("COMPILE_FLAGS"); - } - if(cmSystemTools::GetFileFormat( - cc->second.m_SourceFile->GetSourceExtension().c_str()) - == cmSystemTools::CXX_FILE_FORMAT) - { - // force a C++ file type - compileFlags += " /TP "; - } - // Check for extra object-file dependencies. - const char* deps = - cc->second.m_SourceFile->GetProperty("OBJECT_DEPENDS"); - if(deps) + compileFlags = cflags; + } + if(cmSystemTools::GetFileFormat((*sf)->GetSourceExtension().c_str()) + == cmSystemTools::CXX_FILE_FORMAT) + { + // force a C++ file type + compileFlags += " /TP "; + } + // Check for extra object-file dependencies. + const char* deps = (*sf)->GetProperty("OBJECT_DEPENDS"); + if(deps) + { + std::vector<std::string> depends; + cmSystemTools::ExpandListArgument(deps, depends); + if(!depends.empty()) { - std::vector<std::string> depends; - cmSystemTools::ExpandListArgument(deps, depends); - if(!depends.empty()) + std::vector<std::string>::iterator i = depends.begin(); + additionalDeps = this->ConvertToXMLOutputPath(i->c_str()); + for(++i;i != depends.end(); ++i) { - std::vector<std::string>::iterator i = depends.begin(); - additionalDeps = this->ConvertToXMLOutputPath(i->c_str()); - for(++i;i != depends.end(); ++i) - { - additionalDeps += ";"; - additionalDeps += this->ConvertToXMLOutputPath(i->c_str()); - } + additionalDeps += ";"; + additionalDeps += this->ConvertToXMLOutputPath(i->c_str()); } } } @@ -767,18 +822,20 @@ void cmLocalVisualStudio7Generator::WriteVCProjFile(std::ostream& fout, // Tell MS-Dev what the source is. If the compiler knows how to // build it, then it will. fout << "\t\t\t\tRelativePath=\"" << d << "\">\n"; - if (!commands.empty()) + if (command) { - cmSourceGroup::CommandFiles totalCommand; std::string totalCommandStr; - totalCommandStr = this->CombineCommands(commands, totalCommand, - source.c_str()); - const char* comment = totalCommand.m_Comment.c_str(); + totalCommandStr = + cmSystemTools::ConvertToOutputPath(command->GetCommand().c_str()); + totalCommandStr += " "; + totalCommandStr += command->GetArguments(); + totalCommandStr += "\n"; + const char* comment = command->GetComment().c_str(); const char* flags = compileFlags.size() ? compileFlags.c_str(): 0; this->WriteCustomRule(fout, source.c_str(), totalCommandStr.c_str(), (*comment?comment:"Custom Rule"), - totalCommand.m_Depends, - totalCommand.m_Outputs, flags); + command->GetDepends(), + command->GetOutput().c_str(), flags); } else if(compileFlags.size() || additionalDeps.length()) { @@ -820,13 +877,14 @@ void cmLocalVisualStudio7Generator::WriteVCProjFile(std::ostream& fout, } -void cmLocalVisualStudio7Generator::WriteCustomRule(std::ostream& fout, - const char* source, - const char* command, - const char* comment, - const std::set<std::string>& depends, - const std::set<std::string>& outputs, - const char* compileFlags) +void cmLocalVisualStudio7Generator:: +WriteCustomRule(std::ostream& fout, + const char* source, + const char* command, + const char* comment, + const std::vector<std::string>& depends, + const char *output, + const char* compileFlags) { std::string cmd = command; cmSystemTools::ReplaceString(cmd, "\"", """); @@ -847,17 +905,13 @@ void cmLocalVisualStudio7Generator::WriteCustomRule(std::ostream& fout, fout << "\t\t\t\t\t<Tool\n" << "\t\t\t\t\tName=\"VCCustomBuildTool\"\n" << "\t\t\t\t\tDescription=\"Building " << comment; - std::set<std::string>::const_iterator it; - for ( it = outputs.begin(); it != outputs.end(); it ++ ) - { - fout << " " << *it; - } + fout << " " << output; fout << "\"\n" << "\t\t\t\t\tCommandLine=\"" << cmd << "\n\"\n" << "\t\t\t\t\tAdditionalDependencies=\""; // Write out the dependencies for the rule. std::string temp; - for(std::set<std::string>::const_iterator d = depends.begin(); + for(std::vector<std::string>::const_iterator d = depends.begin(); d != depends.end(); ++d) { fout << this->ConvertToXMLOutputPath(d->c_str()) @@ -865,26 +919,14 @@ void cmLocalVisualStudio7Generator::WriteCustomRule(std::ostream& fout, } fout << "\"\n"; fout << "\t\t\t\t\tOutputs=\""; - if(outputs.size() == 0) + if(output == 0) { fout << source << "_force"; } bool first = true; - // Write a rule for every output generated by this command. - for(std::set<std::string>::const_iterator output = outputs.begin(); - output != outputs.end(); ++output) - { - if(!first) - { - fout << ";"; - } - else - { - first = false; - } - fout << this->ConvertToXMLOutputPathSingle(output->c_str()); - } + // Write a rule for the output generated by this command. + fout << this->ConvertToXMLOutputPathSingle(output); fout << "\"/>\n"; fout << "\t\t\t\t</FileConfiguration>\n"; } @@ -907,85 +949,90 @@ void cmLocalVisualStudio7Generator::WriteVCProjEndGroup(std::ostream& fout) } - - - -std::string -cmLocalVisualStudio7Generator::CombineCommands( - const cmSourceGroup::Commands &commands, - cmSourceGroup::CommandFiles &totalCommand, - const char *source) - +// look for custom rules on a target and collect them together +void cmLocalVisualStudio7Generator::OutputTargetRules(std::ostream& fout, + const cmTarget &target, + const char *libName) { - // Loop through every custom command generating code from the - // current source. - // build up the depends and outputs and commands - std::string totalCommandStr = ""; - std::string temp; - for(cmSourceGroup::Commands::const_iterator c = commands.begin(); - c != commands.end(); ++c) + if (target.GetType() > cmTarget::UTILITY) { - temp= - cmSystemTools::ConvertToOutputPath(c->second.m_Command.c_str()); - totalCommandStr += temp; - totalCommandStr += " "; - totalCommandStr += c->second.m_Arguments; - totalCommandStr += "\n"; - totalCommand.Merge(c->second); - totalCommand.m_Comment = c->second.m_Comment.c_str(); - } - // Create a dummy file with the name of the source if it does - // not exist - if(totalCommand.m_Outputs.empty()) - { - std::string dummyFile = m_Makefile->GetStartOutputDirectory(); - dummyFile += "/"; - dummyFile += source; - if(!cmSystemTools::FileExists(dummyFile.c_str())) + return; + } + + // add the pre build rules + fout << "\t\t\t<Tool\n\t\t\t\tName=\"VCPreBuildEventTool\""; + bool init = false; + for (std::vector<cmCustomCommand>::const_iterator cr = + target.GetPreBuildCommands().begin(); + cr != target.GetPreBuildCommands().end(); ++cr) + { + cmCustomCommand cc(*cr); + cc.ExpandVariables(*m_Makefile); + if(!init) { - std::ofstream fout(dummyFile.c_str()); - fout << "Dummy file created by cmake as unused source for utility command.\n"; + fout << "\nCommandLine=\""; + init = true; } + std::string args = cc.GetArguments(); + cmSystemTools::ReplaceString(args, "\"", """); + fout << this->ConvertToXMLOutputPath(cc.GetCommand().c_str()) << " " << + args << "\n"; } - return totalCommandStr; -} - - -// look for custom rules on a target and collect them together + if (init) + { + fout << "\""; + } + fout << "/>\n"; -void cmLocalVisualStudio7Generator::OutputTargetRules(std::ostream& fout, - const cmTarget &target, - const char *libName) -{ - if (target.GetType() >= cmTarget::UTILITY) + // add the pre Link rules + fout << "\t\t\t<Tool\n\t\t\t\tName=\"VCPreLinkEventTool\""; + init = false; + for (std::vector<cmCustomCommand>::const_iterator cr = + target.GetPreLinkCommands().begin(); + cr != target.GetPreLinkCommands().end(); ++cr) { - return; + cmCustomCommand cc(*cr); + cc.ExpandVariables(*m_Makefile); + if(!init) + { + fout << "\nCommandLine=\""; + init = true; + } + std::string args = cc.GetArguments(); + cmSystemTools::ReplaceString(args, "\"", """); + fout << this->ConvertToXMLOutputPath(cc.GetCommand().c_str()) << " " << + args << "\n"; + } + if (init) + { + fout << "\""; } + fout << "/>\n"; - // Find the group in which the lix exe custom rules belong - bool init = false; + // add the PostBuild rules + fout << "\t\t\t<Tool\n\t\t\t\tName=\"VCPostBuildEventTool\""; + init = false; for (std::vector<cmCustomCommand>::const_iterator cr = - target.GetCustomCommands().begin(); - cr != target.GetCustomCommands().end(); ++cr) + target.GetPostBuildCommands().begin(); + cr != target.GetPostBuildCommands().end(); ++cr) { cmCustomCommand cc(*cr); cc.ExpandVariables(*m_Makefile); - if (cc.GetSourceName() == libName) + if(!init) { - if(!init) - { - fout << "\nCommandLine=\""; - init = true; - } - std::string args = cc.GetArguments(); - cmSystemTools::ReplaceString(args, "\"", """); - fout << this->ConvertToXMLOutputPath(cc.GetCommand().c_str()) << " " << args << "\n"; + fout << "\nCommandLine=\""; + init = true; } + std::string args = cc.GetArguments(); + cmSystemTools::ReplaceString(args, "\"", """); + fout << this->ConvertToXMLOutputPath(cc.GetCommand().c_str()) << " " << + args << "\n"; } if (init) { fout << "\""; } + fout << "/>\n"; } void diff --git a/Source/cmLocalVisualStudio7Generator.h b/Source/cmLocalVisualStudio7Generator.h index 9469c5f..df711b7 100644 --- a/Source/cmLocalVisualStudio7Generator.h +++ b/Source/cmLocalVisualStudio7Generator.h @@ -22,9 +22,8 @@ class cmMakeDepend; class cmTarget; class cmSourceFile; - -// please remove me.... Yuck -#include "cmSourceGroup.h" +class cmCustomCommand; +class cmSourceGroup; /** \class cmLocalVisualStudio7Generator * \brief Write a LocalUnix makefiles. @@ -74,7 +73,7 @@ private: void CreateSingleVCProj(const char *lname, cmTarget &tgt); void WriteVCProjFile(std::ostream& fout, const char *libName, cmTarget &tgt); - void AddVCProjBuildRule(cmSourceGroup&); + void AddVCProjBuildRule(); void WriteConfigurations(std::ostream& fout, const char *libName, const cmTarget &tgt); @@ -107,15 +106,12 @@ private: const char* group, const char* filter); void WriteVCProjEndGroup(std::ostream& fout); - std::string CombineCommands(const cmSourceGroup::Commands &commands, - cmSourceGroup::CommandFiles &totalCommand, - const char *source); void WriteCustomRule(std::ostream& fout, const char* source, const char* command, const char* comment, - const std::set<std::string>& depends, - const std::set<std::string>& outputs, + const std::vector<std::string>& depends, + const char* output, const char* extraFlags); std::vector<std::string> m_CreatedProjectNames; diff --git a/Source/cmMakefile.cxx b/Source/cmMakefile.cxx index a71de1b..661841b 100644 --- a/Source/cmMakefile.cxx +++ b/Source/cmMakefile.cxx @@ -65,6 +65,7 @@ cmMakefile::cmMakefile() this->AddSourceGroup("Source Files", "\\.(C|M|c|c\\+\\+|cc|cpp|cxx|m|mm|rc|def|r|odl|idl|hpj|bat)$"); this->AddSourceGroup("Header Files", "\\.(h|h\\+\\+|hm|hpp|hxx|in|txx|inl)$"); + this->AddSourceGroup("CMake Rules", "\\.rule$"); this->AddDefaultDefinitions(); } @@ -169,7 +170,7 @@ void cmMakefile::Print() const for( std::vector<cmSourceGroup>::const_iterator i = m_SourceGroups.begin(); i != m_SourceGroups.end(); ++i) { - i->Print(); + std::cout << "Source Group: " << i->GetName() << std::endl; } } @@ -441,6 +442,7 @@ void cmMakefile::ConfigureFinalPass() } +// this is the old style signature, we convert to new style void cmMakefile::AddCustomCommand(const char* source, const char* command, const std::vector<std::string>& commandArgs, @@ -449,13 +451,137 @@ void cmMakefile::AddCustomCommand(const char* source, const char *target, const char *comment) { + if (strcmp(source,target)) + { + // what a pain, for backwards compatibility we will try to + // convert this to an output based rule... so for each output.. + for(std::vector<std::string>::const_iterator d = outputs.begin(); + d != outputs.end(); ++d) + { + this->AddCustomCommandToOutput(d->c_str(), command, commandArgs, + source, depends, comment); + // add the output to the target? + std::string sname = *d; + sname += ".rule"; + if (!this->GetSource(sname.c_str())) + { + m_Targets[target].GetSourceLists().push_back(source); + } + } + } + else + { + this->AddCustomCommandToTarget(target, command, commandArgs, + cmTarget::POST_BUILD, + comment); + } +} + +void cmMakefile::AddCustomCommand(const char* source, + const char* command, + const std::vector<std::string>& commandArgs, + const std::vector<std::string>& depends, + const char* output, + const char *target) +{ + std::vector<std::string> outputs; + outputs.push_back(output); + this->AddCustomCommand(source, command, commandArgs, depends, + outputs, target); +} + +void cmMakefile:: +AddCustomCommandToOutput(const char* output, + const char* command, + const std::vector<std::string>& commandArgs, + const char *main_dependency, + const std::vector<std::string>& depends, + const char *comment, + bool replace) +{ + cmSourceFile *file = 0; + std::string outName = output; + outName += ".rule"; + + // OK this rule will be placed on a generated output file unless the main + // depednency was specified. + if (main_dependency && main_dependency[0] != '\0') + { + file = this->GetSource(main_dependency); + if (file && file->GetCustomCommand() && !replace) + { + // generate a source instead + file = 0; + } + else + { + file = this->GetOrCreateSource(main_dependency); + } + } + + if (!file) + { + file = this->GetSource(outName.c_str()); + if (file && file->GetCustomCommand() && !replace) + { + cmSystemTools::Error("Attempt to add a custom rule to an output that already has a custom rule. For output: ", output); + return; + } + // create a cmSourceFile for the output + file = this->GetOrCreateSource(outName.c_str(), true); + // always mark as generated + file->SetProperty("GENERATED","1"); + } + + // always create the output and mark it generated + cmSourceFile *out = this->GetOrCreateSource(output, true); + out->SetProperty("GENERATED","1"); + + // process the command + std::string expandC = command; + this->ExpandVariablesInString(expandC); + std::string c = cmSystemTools::EscapeSpaces(expandC.c_str()); + + std::string combinedArgs; + unsigned int i; + for (i = 0; i < commandArgs.size(); ++i) + { + expandC = commandArgs[i].c_str(); + this->ExpandVariablesInString(expandC); + combinedArgs += cmSystemTools::EscapeSpaces(expandC.c_str()); + combinedArgs += " "; + } + std::vector<std::string> depends2(depends); + if (main_dependency && main_dependency[0] != '\0') + { + depends2.push_back(main_dependency); + } + cmCustomCommand *cc = + new cmCustomCommand(c.c_str(),combinedArgs.c_str(),depends2, output); + if ( comment && comment[0] ) + { + cc->SetComment(comment); + } + if (file->GetCustomCommand()) + { + delete file->GetCustomCommand(); + } + file->SetCustomCommand(cc); +} + +void cmMakefile:: +AddCustomCommandToTarget(const char* target, const char* command, + const std::vector<std::string>& commandArgs, + cmTarget::CustomCommandType type, + const char *comment) +{ // find the target, if (m_Targets.find(target) != m_Targets.end()) { std::string expandC = command; this->ExpandVariablesInString(expandC); std::string c = cmSystemTools::EscapeSpaces(expandC.c_str()); - + std::string combinedArgs; unsigned int i; @@ -467,12 +593,23 @@ void cmMakefile::AddCustomCommand(const char* source, combinedArgs += " "; } - cmCustomCommand cc(source,c.c_str(),combinedArgs.c_str(),depends,outputs); + cmCustomCommand cc(c.c_str(),combinedArgs.c_str()); if ( comment && comment[0] ) { cc.SetComment(comment); } - m_Targets[target].GetCustomCommands().push_back(cc); + switch (type) + { + case cmTarget::PRE_BUILD: + m_Targets[target].GetPreBuildCommands().push_back(cc); + break; + case cmTarget::PRE_LINK: + m_Targets[target].GetPreLinkCommands().push_back(cc); + break; + case cmTarget::POST_BUILD: + m_Targets[target].GetPostBuildCommands().push_back(cc); + break; + } std::string cacheCommand = command; this->ExpandVariablesInString(cacheCommand); if(this->GetCacheManager()->GetCacheValue(cacheCommand.c_str())) @@ -483,18 +620,6 @@ void cmMakefile::AddCustomCommand(const char* source, } } -void cmMakefile::AddCustomCommand(const char* source, - const char* command, - const std::vector<std::string>& commandArgs, - const std::vector<std::string>& depends, - const char* output, - const char *target) -{ - std::vector<std::string> outputs; - outputs.push_back(output); - this->AddCustomCommand(source, command, commandArgs, depends, outputs, target); -} - void cmMakefile::AddDefineFlag(const char* flag) { m_DefineFlags += " "; @@ -799,11 +924,12 @@ void cmMakefile::AddExecutable(const char *exeName, void cmMakefile::AddUtilityCommand(const char* utilityName, const char* command, const char* arguments, - bool all) + bool all, + const std::vector<std::string> &depends) { std::vector<std::string> empty; this->AddUtilityCommand(utilityName,command,arguments,all, - empty,empty); + depends, empty); } void cmMakefile::AddUtilityCommand(const char* utilityName, @@ -816,11 +942,54 @@ void cmMakefile::AddUtilityCommand(const char* utilityName, cmTarget target; target.SetType(cmTarget::UTILITY); target.SetInAll(all); - cmCustomCommand cc(utilityName, command, arguments, dep, out); - target.GetCustomCommands().push_back(cc); + if (out.size() > 1) + { + cmSystemTools::Error( + "Utility targets can only have one output. For utilityNamed: ", + utilityName); + return; + } + if (out.size()) + { + cmCustomCommand cc(command, arguments, dep, out[0].c_str()); + target.GetPostBuildCommands().push_back(cc); + } + else + { + cmCustomCommand cc(command, arguments, dep, NULL); + target.GetPostBuildCommands().push_back(cc); + } m_Targets.insert(cmTargets::value_type(utilityName,target)); } +cmSourceFile *cmMakefile::GetSourceFileWithOutput(const char *cname) +{ + std::string name = cname; + + // look through all the source files that have custom commands + // and see if the custom command has the passed source file as an output + // keep in mind the possible .rule extension that may be tacked on + for(std::vector<cmSourceFile*>::const_iterator i = m_SourceFiles.begin(); + i != m_SourceFiles.end(); ++i) + { + // does this source file have a custom command? + if ((*i)->GetCustomCommand()) + { + // is the output of the custom command match the source files name + std::string out = (*i)->GetCustomCommand()->GetOutput(); + if (out.rfind(name) != out.npos && + out.rfind(name) == out.size() - name.size()) + { + return *i; + } + } + } + + // otherwise return NULL + return NULL; +} + + cmSourceGroup* cmMakefile::GetSourceGroup(const char* name) { // First see if the group exists. If so, replace its regular expression. @@ -946,6 +1115,19 @@ void cmMakefile::ExpandVariables() } } +void cmMakefile::ExpandVariablesInCustomCommands() +{ + for(std::vector<cmSourceFile*>::iterator i = m_SourceFiles.begin(); + i != m_SourceFiles.end(); ++i) + { + cmCustomCommand *cc = (*i)->GetCustomCommand(); + if (cc) + { + cc->ExpandVariables(*this); + } + } +} + bool cmMakefile::IsOn(const char* name) const { const char* value = this->GetDefinition(name); @@ -1254,7 +1436,7 @@ cmMakefile::FindSourceGroup(const char* source, std::string::size_type pos = file.rfind('/'); if(pos != std::string::npos) { - file = file.substr(pos, file.length()-pos); + file = file.substr(pos+1); } for(std::vector<cmSourceGroup>::reverse_iterator sg = groups.rbegin(); @@ -1402,11 +1584,11 @@ cmSourceFile* cmMakefile::GetSource(const char* sourceName) const { std::string s = cmSystemTools::GetFilenameName(sourceName); std::string ext; - std::string::size_type pos = s.rfind('.'); - if(pos != std::string::npos) + ext = cmSystemTools::GetFilenameLastExtension(s); + s = s.substr(0, s.length()-ext.length()); + if ( ext.length() && ext[0] == '.' ) { - ext = s.substr(pos+1, s.size() - pos-1); - s = s.substr(0, pos); + ext = ext.substr(1); } for(std::vector<cmSourceFile*>::const_iterator i = m_SourceFiles.begin(); i != m_SourceFiles.end(); ++i) @@ -1422,8 +1604,71 @@ cmSourceFile* cmMakefile::GetSource(const char* sourceName) const return 0; } +cmSourceFile* cmMakefile::GetOrCreateSource(const char* sourceName, + bool generated) +{ + // check to see if it exists + cmSourceFile* ret = this->GetSource(sourceName); + if (ret) + { + return ret; + } + + // we must create one + std::string newfile = sourceName; + cmSourceFile file; + std::string path = cmSystemTools::GetFilenamePath(newfile); + if(generated) + { + std::string ext = cmSystemTools::GetFilenameLastExtension(newfile); + std::string name_no_ext = cmSystemTools::GetFilenameName(newfile.c_str()); + name_no_ext = name_no_ext.substr(0, name_no_ext.length()-ext.length()); + if ( ext.length() && ext[0] == '.' ) + { + ext = ext.substr(1); + } + if((path.size() && path[0] == '/') || + (path.size() > 1 && path[1] == ':')) + { + file.SetName(name_no_ext.c_str(), path.c_str(), ext.c_str(), false); + } + else + { + file.SetName(name_no_ext.c_str(), this->GetCurrentOutputDirectory(), + ext.c_str(), false); + } + } + else + { + // if this is a full path then + if((path.size() && path[0] == '/') || + (path.size() > 1 && path[1] == ':')) + { + file.SetName(cmSystemTools::GetFilenameName(newfile.c_str()).c_str(), + path.c_str(), + this->GetSourceExtensions(), + this->GetHeaderExtensions()); + } + else + { + file.SetName(newfile.c_str(), this->GetCurrentDirectory(), + this->GetSourceExtensions(), + this->GetHeaderExtensions()); + } + } + // add the source file to the makefile + this->AddSource(file); + ret = this->GetSource(sourceName); + if (!ret) + { + cmSystemTools::Error( + "CMake failed to properly look up cmSourceFile: ", sourceName); + int i = *(int *)0x0; + } + return ret; +} - + cmSourceFile* cmMakefile::AddSource(cmSourceFile const&sf) { // check to see if it exists diff --git a/Source/cmMakefile.h b/Source/cmMakefile.h index 3180847..93d02c8 100644 --- a/Source/cmMakefile.h +++ b/Source/cmMakefile.h @@ -121,6 +121,22 @@ public: /** * Add a custom command to the build. */ + void AddCustomCommandToOutput(const char* output, + const char* command, + const std::vector<std::string>& commandArgs, + const char *main_dependency, + const std::vector<std::string>& depends, + const char *comment = 0, + bool replace = false); + void AddCustomCommandToTarget(const char* target, + const char* command, + const std::vector<std::string>& commandArgs, + cmTarget::CustomCommandType type, + const char *comment = 0); + + /** + * Add a custom command to the build. + */ void AddCustomCommand(const char* source, const char* command, const std::vector<std::string>& commandArgs, @@ -156,7 +172,8 @@ public: void AddUtilityCommand(const char* utilityName, const char* command, const char* arguments, - bool all); + bool all, + const std::vector<std::string> &depends); void AddUtilityCommand(const char* utilityName, const char* command, const char* arguments, @@ -417,6 +434,14 @@ public: cmSourceFile* GetSource(const char* sourceName) const; ///! Add a new cmSourceFile to the list of sources for this makefile. cmSourceFile* AddSource(cmSourceFile const&); + + /** Get a cmSourceFile pointer for a given source name, if the name is + * not found, then create the source file and return it. generated + * indicates if it is a generated file, this is used in determining + * how to create the source file instance e.g. name + */ + cmSourceFile* GetOrCreateSource(const char* sourceName, + bool generated = false); /** * Obtain a list of auxiliary source directories. @@ -508,7 +533,8 @@ public: * Expand variables in the makefiles ivars such as link directories etc */ void ExpandVariables(); - + void ExpandVariablesInCustomCommands(); + /** * find what source group this source is in */ @@ -559,6 +585,19 @@ public: */ cmake *GetCMakeInstance() const; + /** + * Get all the source files this makefile knows about + */ + const std::vector<cmSourceFile*> &GetSourceFiles() const + {return m_SourceFiles;} + std::vector<cmSourceFile*> &GetSourceFiles() {return m_SourceFiles;} + + /** + * Is there a source file that has the provided source file as an output? + * if so then return it + */ + cmSourceFile *GetSourceFileWithOutput(const char *outName); + protected: // add link libraries and directories to the target void AddGlobalLinkInformation(const char* name, cmTarget& target); diff --git a/Source/cmSetSourceFilesPropertiesCommand.cxx b/Source/cmSetSourceFilesPropertiesCommand.cxx index e57cfa6..65e85fe 100644 --- a/Source/cmSetSourceFilesPropertiesCommand.cxx +++ b/Source/cmSetSourceFilesPropertiesCommand.cxx @@ -29,6 +29,7 @@ bool cmSetSourceFilesPropertiesCommand::InitialPass( // first collect up the list of files std::vector<std::string> propertyPairs; bool doingFiles = true; + bool generated = false; int numFiles = 0; std::vector<std::string>::const_iterator j; for(j= args.begin(); j != args.end();++j) @@ -49,6 +50,7 @@ bool cmSetSourceFilesPropertiesCommand::InitialPass( else if(*j == "GENERATED") { doingFiles = false; + generated = true; propertyPairs.push_back("GENERATED"); propertyPairs.push_back("1"); } @@ -84,7 +86,18 @@ bool cmSetSourceFilesPropertiesCommand::InitialPass( while (j != args.end()) { propertyPairs.push_back(*j); - ++j; + if(*j == "GENERATED") + { + ++j; + if(j != args.end() && cmSystemTools::IsOn(j->c_str())) + { + generated = true; + } + } + else + { + ++j; + } if(j == args.end()) { this->SetError("called with incorrect number of arguments."); @@ -112,67 +125,13 @@ bool cmSetSourceFilesPropertiesCommand::InitialPass( unsigned int k; for(i = 0; i < numFiles; ++i) { - // if the file is already in the makefile just set properites on it - cmSourceFile* sf = m_Makefile->GetSource(args[i].c_str()); - if(sf) + // get the source file + cmSourceFile* sf = + m_Makefile->GetOrCreateSource(args[i].c_str(), generated); + // now loop through all the props and set them + for (k = 0; k < propertyPairs.size(); k = k + 2) { - // now loop through all the props and set them - for (k = 0; k < propertyPairs.size(); k = k + 2) - { - sf->SetProperty(propertyPairs[k].c_str(),propertyPairs[k+1].c_str()); - } - } - // if file is not already in the makefile, then add it - else - { - std::string newfile = args[i]; - cmSourceFile file; - std::string path = cmSystemTools::GetFilenamePath(newfile); - // now loop through all the props and set them - for (k = 0; k < propertyPairs.size(); k = k + 2) - { - file.SetProperty(propertyPairs[k].c_str(),propertyPairs[k+1].c_str()); - } - if(file.GetPropertyAsBool("GENERATED")) - { - std::string ext = cmSystemTools::GetFilenameExtension(newfile); - std::string name_no_ext = cmSystemTools::GetFilenameName(newfile.c_str()); - name_no_ext = name_no_ext.substr(0, name_no_ext.length()-ext.length()); - if ( ext.length() && ext[0] == '.' ) - { - ext = ext.substr(1); - } - if((path.size() && path[0] == '/') || - (path.size() > 1 && path[1] == ':')) - { - file.SetName(name_no_ext.c_str(), path.c_str(), ext.c_str(), false); - } - else - { - file.SetName(name_no_ext.c_str(), m_Makefile->GetCurrentOutputDirectory(), - ext.c_str(), false); - } - } - else - { - // if this is a full path then - if((path.size() && path[0] == '/') || - (path.size() > 1 && path[1] == ':')) - { - file.SetName(cmSystemTools::GetFilenameName(newfile.c_str()).c_str(), - path.c_str(), - m_Makefile->GetSourceExtensions(), - m_Makefile->GetHeaderExtensions()); - } - else - { - file.SetName(newfile.c_str(), m_Makefile->GetCurrentDirectory(), - m_Makefile->GetSourceExtensions(), - m_Makefile->GetHeaderExtensions()); - } - } - // add the source file to the makefile - m_Makefile->AddSource(file); + sf->SetProperty(propertyPairs[k].c_str(),propertyPairs[k+1].c_str()); } } return true; diff --git a/Source/cmSourceFile.h b/Source/cmSourceFile.h index e04a856..d6d1744 100644 --- a/Source/cmSourceFile.h +++ b/Source/cmSourceFile.h @@ -18,6 +18,7 @@ #define cmSourceFile_h #include "cmStandardIncludes.h" +#include "cmCustomCommand.h" /** \class cmSourceFile * \brief Represent a class loaded from a makefile. @@ -34,6 +35,11 @@ public: */ cmSourceFile() { + m_CustomCommand = 0; + } + ~cmSourceFile() + { + if (m_CustomCommand) { delete m_CustomCommand; } } /** @@ -46,6 +52,15 @@ public: const std::vector<std::string>& headerExts); /** + * Get the list of the custom commands for this source file + */ + const cmCustomCommand *GetCustomCommand() const + {return m_CustomCommand;} + cmCustomCommand *GetCustomCommand() {return m_CustomCommand;} + void SetCustomCommand(cmCustomCommand *cc) + { m_CustomCommand = cc;} + + /** * Set the name of the file, given the directory the file should be in. IN * this version the extension is provided in the call. This is useful for * generated files that do not exist prior to the build. @@ -77,8 +92,7 @@ public: void SetSourceName(const char *name) {m_SourceName = name;} /** - * The file name associated with stripped off directory and extension. - * (In most cases this is the name of the class.) + * The file extension associated with source file */ const std::string &GetSourceExtension() const {return m_SourceExtension;} void SetSourceExtension(const char *name) {m_SourceExtension = name;} @@ -90,8 +104,8 @@ public: std::vector<std::string> &GetDepends() {return m_Depends;} private: - std::map<cmStdString,cmStdString> m_Properties; + cmCustomCommand *m_CustomCommand; std::string m_FullPath; std::string m_SourceName; std::string m_SourceExtension; diff --git a/Source/cmSourceGroup.cxx b/Source/cmSourceGroup.cxx index 081f299..8815e30 100644 --- a/Source/cmSourceGroup.cxx +++ b/Source/cmSourceGroup.cxx @@ -33,7 +33,7 @@ cmSourceGroup::cmSourceGroup(const char* name, const char* regex): cmSourceGroup::cmSourceGroup(const cmSourceGroup& r): m_Name(r.m_Name), m_GroupRegex(r.m_GroupRegex), - m_BuildRules(r.m_BuildRules) + m_SourceFiles(r.m_SourceFiles) { } @@ -52,100 +52,6 @@ bool cmSourceGroup::Matches(const char* name) */ void cmSourceGroup::AddSource(const char* name, const cmSourceFile* sf) { - BuildRules::iterator s = m_BuildRules.find(name); - if(s == m_BuildRules.end()) - { - SourceAndCommands sc; - sc.m_SourceFile = sf; - // The source was not found. Add it with no commands. - m_BuildRules[name] = sc; - return; - } + m_SourceFiles.push_back(sf); } - -/** - * Add a source and corresponding custom command to the group. If the - * source already exists, the command will be added to its set of commands. - * If the command also already exists, the given dependencies and outputs - * are added to it. - */ -void cmSourceGroup::AddCustomCommand(const cmCustomCommand &cmd) -{ - std::string commandAndArgs = cmd.GetCommandAndArguments(); - BuildRules::iterator s = m_BuildRules.find(cmd.GetSourceName()); - if(s == m_BuildRules.end()) - { - // The source was not found. Add it with this command. - CommandFiles& cmdFiles = - m_BuildRules[cmd.GetSourceName()].m_Commands[commandAndArgs]; - cmdFiles.m_Command = cmd.GetCommand(); - cmdFiles.m_Comment = cmd.GetComment(); - cmdFiles.m_Arguments = cmd.GetArguments(); - cmdFiles.m_Depends.insert(cmd.GetDepends().begin(),cmd.GetDepends().end()); - cmdFiles.m_Outputs.insert(cmd.GetOutputs().begin(),cmd.GetOutputs().end()); - return; - } - - // The source already exists. See if the command exists. - Commands& commands = s->second.m_Commands; - Commands::iterator c = commands.find(commandAndArgs); - if(c == commands.end()) - { - // The command did not exist. Add it. - commands[commandAndArgs].m_Command = cmd.GetCommand(); - commands[commandAndArgs].m_Comment = cmd.GetComment(); - commands[commandAndArgs].m_Arguments = cmd.GetArguments(); - commands[commandAndArgs].m_Depends.insert(cmd.GetDepends().begin(), - cmd.GetDepends().end()); - commands[commandAndArgs].m_Outputs.insert(cmd.GetOutputs().begin(), - cmd.GetOutputs().end()); - return; - } - - // The command already exists for this source. Merge the sets. - CommandFiles& commandFiles = c->second; - commandFiles.m_Depends.insert(cmd.GetDepends().begin(), - cmd.GetDepends().end()); - commandFiles.m_Outputs.insert(cmd.GetOutputs().begin(), - cmd.GetOutputs().end()); -} - -void cmSourceGroup::Print() const -{ - std::cout << "cmSourceGroup: " << m_Name.c_str() << "\n"; - for(BuildRules::const_iterator i = m_BuildRules.begin(); - i != m_BuildRules.end(); ++i) - { - std::cout << "BuildRule: " << i->first.c_str() << "\n"; - for(Commands::const_iterator j = i->second.m_Commands.begin(); - j != i->second.m_Commands.end(); ++j) - { - std::cout << "FullCommand: " << j->first.c_str() << "\n"; - std::cout << "Command: " << j->second.m_Command.c_str() << "\n"; - std::cout << "Arguments: " << j->second.m_Arguments.c_str() << "\n"; - std::cout << "Command Outputs " - << static_cast<int>(j->second.m_Outputs.size()) << "\n"; - std::cout << "Command Depends " - << static_cast<int>(j->second.m_Depends.size()) << "\n"; - } - } -} - - -void cmSourceGroup::CommandFiles::Merge(const CommandFiles &r) -{ - std::set<std::string>::const_iterator dep = r.m_Depends.begin(); - std::set<std::string>::const_iterator out = r.m_Outputs.begin(); - for (;dep != r.m_Depends.end(); ++dep) - { - this->m_Depends.insert(*dep); - } - for (;out != r.m_Outputs.end(); ++out) - { - this->m_Outputs.insert(*out); - } -} - - - diff --git a/Source/cmSourceGroup.h b/Source/cmSourceGroup.h index 6c3fe4d..0dbd8cc 100644 --- a/Source/cmSourceGroup.h +++ b/Source/cmSourceGroup.h @@ -19,7 +19,6 @@ #include "cmStandardIncludes.h" #include "cmRegularExpression.h" -#include "cmCustomCommand.h" class cmSourceFile; /** \class cmSourceGroup @@ -35,47 +34,20 @@ public: cmSourceGroup(const cmSourceGroup&); ~cmSourceGroup() {} - struct CommandFiles - { - CommandFiles() {} - CommandFiles(const CommandFiles& r): - m_Comment(r.m_Comment), m_Outputs(r.m_Outputs), m_Depends(r.m_Depends) {} - - void Merge(const CommandFiles &r); - - std::string m_Command; - std::string m_Arguments; - std::string m_Comment; - std::set<std::string> m_Outputs; - std::set<std::string> m_Depends; - }; - - /** - * Map from command to its output/depends sets. - */ - typedef std::map<cmStdString, CommandFiles> Commands; - - struct SourceAndCommands - { - SourceAndCommands(): m_SourceFile(0) {} - const cmSourceFile* m_SourceFile; - Commands m_Commands; - }; - /** - * Map from source to command map. - */ - typedef std::map<cmStdString, SourceAndCommands> BuildRules; - - bool Matches(const char* name); void SetGroupRegex(const char* regex) { m_GroupRegex.compile(regex); } void AddSource(const char* name, const cmSourceFile*); - void AddCustomCommand(const cmCustomCommand &cmd); const char* GetName() const { return m_Name.c_str(); } - const BuildRules& GetBuildRules() const - { return m_BuildRules; } - void Print() const; + bool Matches(const char *); + + /** + * Get the list of the source files used by this target + */ + const std::vector<const cmSourceFile*> &GetSourceFiles() const + {return m_SourceFiles;} + std::vector<const cmSourceFile*> &GetSourceFiles() {return m_SourceFiles;} + private: /** * The name of the source group. @@ -88,11 +60,9 @@ private: cmRegularExpression m_GroupRegex; /** - * Map from source name to the commands to build from the source. - * Some commands may build from files that the compiler also knows how to - * build. + * vector of all source files in this source group */ - BuildRules m_BuildRules; + std::vector<const cmSourceFile*> m_SourceFiles; }; #endif diff --git a/Source/cmSystemTools.cxx b/Source/cmSystemTools.cxx index 46bcabd..0ef39fd 100644 --- a/Source/cmSystemTools.cxx +++ b/Source/cmSystemTools.cxx @@ -1932,6 +1932,25 @@ std::string cmSystemTools::GetFilenameExtension(const std::string& filename) } } +/** + * Return file extension of a full filename (dot included). + * Warning: this is the shortest extension (for example: .tar.gz) + */ +std::string +cmSystemTools::GetFilenameLastExtension(const std::string& filename) +{ + std::string name = cmSystemTools::GetFilenameName(filename); + std::string::size_type dot_pos = name.rfind("."); + if(dot_pos != std::string::npos) + { + return name.substr(dot_pos); + } + else + { + return ""; + } +} + /** * Return file name without extension of a full filename (i.e. without path). diff --git a/Source/cmSystemTools.h b/Source/cmSystemTools.h index 24ac737..8317e64 100644 --- a/Source/cmSystemTools.h +++ b/Source/cmSystemTools.h @@ -284,6 +284,9 @@ public: ///! return file extension of a full filename (dot included). static std::string GetFilenameExtension(const std::string&); + ///! return file extension of a full filename (dot included). + static std::string GetFilenameLastExtension(const std::string&); + ///! return file name without extension of a full filename. static std::string GetFilenameWithoutExtension(const std::string&); diff --git a/Source/cmTarget.h b/Source/cmTarget.h index 14ee770..89dac6a 100644 --- a/Source/cmTarget.h +++ b/Source/cmTarget.h @@ -34,6 +34,8 @@ public: SHARED_LIBRARY, MODULE_LIBRARY, UTILITY, INSTALL_FILES, INSTALL_PROGRAMS }; + enum CustomCommandType { PRE_BUILD, PRE_LINK, POST_BUILD }; + /** * Return the type of target. */ @@ -57,8 +59,18 @@ public: /** * Get the list of the custom commands for this target */ - const std::vector<cmCustomCommand> &GetCustomCommands() const {return m_CustomCommands;} - std::vector<cmCustomCommand> &GetCustomCommands() {return m_CustomCommands;} + const std::vector<cmCustomCommand> &GetPreBuildCommands() const + {return m_PreBuildCommands;} + std::vector<cmCustomCommand> &GetPreBuildCommands() + {return m_PreBuildCommands;} + const std::vector<cmCustomCommand> &GetPreLinkCommands() const + {return m_PreLinkCommands;} + std::vector<cmCustomCommand> &GetPreLinkCommands() + {return m_PreLinkCommands;} + const std::vector<cmCustomCommand> &GetPostBuildCommands() const + {return m_PostBuildCommands;} + std::vector<cmCustomCommand> &GetPostBuildCommands() + {return m_PostBuildCommands;} /** * Get the list of the source lists used by this target @@ -186,7 +198,9 @@ private: private: - std::vector<cmCustomCommand> m_CustomCommands; + std::vector<cmCustomCommand> m_PreBuildCommands; + std::vector<cmCustomCommand> m_PreLinkCommands; + std::vector<cmCustomCommand> m_PostBuildCommands; std::vector<std::string> m_SourceLists; TargetType m_TargetType; std::vector<cmSourceFile*> m_SourceFiles; |