diff options
27 files changed, 936 insertions, 943 deletions
diff --git a/Source/cmAddCustomCommandCommand.cxx b/Source/cmAddCustomCommandCommand.cxx index fd1954b..ac1f4eb 100644 --- a/Source/cmAddCustomCommandCommand.cxx +++ b/Source/cmAddCustomCommandCommand.cxx @@ -15,6 +15,7 @@ =========================================================================*/ #include "cmAddCustomCommandCommand.h" + #include "cmTarget.h" // cmAddCustomCommandCommand @@ -30,8 +31,14 @@ bool cmAddCustomCommandCommand::InitialPass(std::vector<std::string> const& args return false; } - std::string source, command, target, comment, output, main_dependency; - std::vector<std::string> command_args, depends, outputs; + std::string source, target, comment, output, main_dependency; + std::vector<std::string> depends, outputs; + + // Accumulate one command line at a time. + cmCustomCommandLine currentLine; + + // Save all command lines. + cmCustomCommandLines commandLines; cmTarget::CustomCommandType cctype = cmTarget::POST_BUILD; @@ -39,7 +46,6 @@ bool cmAddCustomCommandCommand::InitialPass(std::vector<std::string> const& args doing_source, doing_command, doing_target, - doing_args, doing_depends, doing_main_dependency, doing_output, @@ -61,6 +67,13 @@ bool cmAddCustomCommandCommand::InitialPass(std::vector<std::string> const& args else if(copy == "COMMAND") { doing = doing_command; + + // Save the current command before starting the next command. + if(!currentLine.empty()) + { + commandLines.push_back(currentLine); + currentLine.clear(); + } } else if(copy == "PRE_BUILD") { @@ -80,7 +93,7 @@ bool cmAddCustomCommandCommand::InitialPass(std::vector<std::string> const& args } else if(copy == "ARGS") { - doing = doing_args; + // Ignore this old keyword. } else if (copy == "DEPENDS") { @@ -116,14 +129,11 @@ bool cmAddCustomCommandCommand::InitialPass(std::vector<std::string> const& args main_dependency = copy; break; case doing_command: - command = copy; + currentLine.push_back(copy); break; case doing_target: target = copy; break; - case doing_args: - command_args.push_back(copy); - break; case doing_depends: depends.push_back(copy); break; @@ -140,58 +150,49 @@ bool cmAddCustomCommandCommand::InitialPass(std::vector<std::string> const& args } } - /* At this point we could complain about the lack of arguments. - For the moment, let's say that COMMAND, TARGET are always - required. - */ - if (output.empty() && target.empty()) + // Store the last command line finished. + if(!currentLine.empty()) + { + commandLines.push_back(currentLine); + currentLine.clear(); + } + + // At this point we could complain about the lack of arguments. For + // the moment, let's say that COMMAND, TARGET are always required. + if(output.empty() && target.empty()) { this->SetError("Wrong syntax. A TARGET or OUTPUT must be specified."); return false; } - if (source.empty() - && !target.empty() - && !output.empty()) + if(source.empty() && !target.empty() && !output.empty()) { this->SetError("Wrong syntax. A TARGET and OUTPUT can not both be specified."); return false; } - - // If source is empty, use the target + + // Choose which mode of the command to use. if(source.empty() && output.empty()) { - m_Makefile->AddCustomCommandToTarget(target.c_str(), - command.c_str(), - command_args, - cctype, + // Source is empty, use the target. + std::vector<std::string> no_depends; + m_Makefile->AddCustomCommandToTarget(target.c_str(), no_depends, + commandLines, cctype, comment.c_str()); - return true; } - - // If target is empty, use the output - if(target.empty()) + else if(target.empty()) { - m_Makefile->AddCustomCommandToOutput(output.c_str(), - command.c_str(), - command_args, + // Target is empty, use the output. + m_Makefile->AddCustomCommandToOutput(output.c_str(), depends, main_dependency.c_str(), - depends, + commandLines, comment.c_str()); + } + else + { + // Use the old-style mode for backward compatibility. + m_Makefile->AddCustomCommandOldStyle(target.c_str(), outputs, depends, + source.c_str(), commandLines, comment.c_str()); - return true; } - - // otherwise backwards compatiblity mode - m_Makefile->AddCustomCommand(source.c_str(), - command.c_str(), - command_args, - depends, - outputs, - target.c_str(), - comment.c_str()); - return true; } - - - diff --git a/Source/cmAddCustomCommandCommand.h b/Source/cmAddCustomCommandCommand.h index 6036e3a..de4152b 100644 --- a/Source/cmAddCustomCommandCommand.h +++ b/Source/cmAddCustomCommandCommand.h @@ -65,10 +65,10 @@ public: return "There are two main signatures for ADD_CUSTOM_COMMAND " "The first signature is for adding a custom command " - "to produce an output.\n" + "to produce an output.\n" " ADD_CUSTOM_COMMAND(OUTPUT result\n" - " COMMAND command\n" - " [ARGS [args...]]\n" + " COMMAND command1 [ARGS] [args1...]\n" + " [COMMAND command2 [ARGS] [args2...] ...]\n" " [MAIN_DEPENDENCY depend]\n" " [DEPENDS [depends...]]\n" " [COMMENT comment])\n" @@ -78,14 +78,17 @@ public: "custom command. In makefile terms this creates a new target in the " "following form:\n" " OUTPUT: MAIN_DEPENDENCY DEPENDS\n" - " COMMAND ARGS\n" + " COMMAND\n" + "If more than one command is specified they will be executed in order. " + "The optional ARGS argument is for backward compatibility and will be " + "ignored.\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" + " COMMAND command1 [ARGS] [args1...]\n" + " [COMMAND command2 [ARGS] [args2...] ...]\n" " [COMMENT comment])\n" "This defines a new command that will be associated with " "building the specified target. When the command will " diff --git a/Source/cmAddCustomTargetCommand.cxx b/Source/cmAddCustomTargetCommand.cxx index 04e3b64..ceb5241 100644 --- a/Source/cmAddCustomTargetCommand.cxx +++ b/Source/cmAddCustomTargetCommand.cxx @@ -19,52 +19,88 @@ // cmAddCustomTargetCommand bool cmAddCustomTargetCommand::InitialPass(std::vector<std::string> const& args) { - bool all = false; - if(args.size() < 1 ) { this->SetError("called with incorrect number of arguments"); return false; } - // all target option - std::string arguments; - std::vector<std::string>::const_iterator s = args.begin(); - ++s; // move past args[0] as it is already to be used - if (args.size() >= 2) + // Accumulate one command line at a time. + cmCustomCommandLine currentLine; + + // Save all command lines. + cmCustomCommandLines commandLines; + + // Accumulate dependencies. + std::vector<std::string> depends; + + // Keep track of parser state. + enum tdoing { + doing_command, + doing_depends + }; + tdoing doing = doing_command; + + // Look for the ALL option. + bool all = false; + unsigned int start = 1; + if(args.size() > 1) { - if (args[1] == "ALL") + if(args[1] == "ALL") { all = true; - ++s; // skip all + start = 2; } } - std::string command; - if(s != args.end() && *s != "DEPENDS") - { - command = *s; - ++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()) + + // Parse the rest of the arguments. + for(unsigned int j = start; j < args.size(); ++j) { - ++s; + std::string const& copy = args[j]; + + if(copy == "DEPENDS") + { + doing = doing_depends; + } + else if(copy == "COMMAND") + { + doing = doing_command; + + // Save the current command before starting the next command. + if(!currentLine.empty()) + { + commandLines.push_back(currentLine); + currentLine.clear(); + } + } + else + { + switch (doing) + { + case doing_command: + currentLine.push_back(copy); + break; + case doing_depends: + depends.push_back(copy); + break; + default: + this->SetError("Wrong syntax. Unknown type of argument."); + return false; + } + } } - while (s != args.end()) + + // Store the last command line finished. + if(!currentLine.empty()) { - depends.push_back(*s); - ++s; + commandLines.push_back(currentLine); + currentLine.clear(); } - m_Makefile->AddUtilityCommand(args[0].c_str(), - command.c_str(), - arguments.c_str(), all, depends); + + // Add the utility target to the makefile. + const char* no_output = 0; + m_Makefile->AddUtilityCommand(args[0].c_str(), all, no_output, depends, + commandLines); return true; } - diff --git a/Source/cmAddCustomTargetCommand.h b/Source/cmAddCustomTargetCommand.h index f7bb40b..6772d58 100644 --- a/Source/cmAddCustomTargetCommand.h +++ b/Source/cmAddCustomTargetCommand.h @@ -63,9 +63,10 @@ public: virtual const char* GetFullDocumentation() { return - " ADD_CUSTOM_TARGET(Name [ALL] [ command arg arg arg ... ]\n" + " ADD_CUSTOM_TARGET(Name [ALL] [command1 [args1...]]\n" + " [COMMAND command2 [args2...] ...]\n" " [DEPENDS depend depend depend ... ])\n" - "Adds a target with the given name that executes the given command " + "Adds a target with the given name that executes the given commands " "every time the target is built. If the ALL option is specified " "it indicates that this target should be added to the default build " "target so that it will be run every time. " diff --git a/Source/cmCPluginAPI.cxx b/Source/cmCPluginAPI.cxx index 41c9337..b460318 100644 --- a/Source/cmCPluginAPI.cxx +++ b/Source/cmCPluginAPI.cxx @@ -203,20 +203,44 @@ void cmAddUtilityCommand(void *arg, const char* utilityName, int numOutputs, const char **outputs) { - cmMakefile *mf = static_cast<cmMakefile *>(arg); + // Get the makefile instance. Perform an extra variable expansion + // now because the API caller expects it. + cmMakefile* mf = static_cast<cmMakefile*>(arg); + + // Construct the command line for the command. + cmCustomCommandLine commandLine; + std::string expand = command; + commandLine.push_back(mf->ExpandVariablesInString(expand)); + if(arguments && arguments[0]) + { + // TODO: Parse arguments! + expand = arguments; + commandLine.push_back(mf->ExpandVariablesInString(expand)); + } + cmCustomCommandLines commandLines; + commandLines.push_back(commandLine); + + // Accumulate the list of dependencies. std::vector<std::string> depends2; - int i; - for (i = 0; i < numDepends; ++i) + for(int i = 0; i < numDepends; ++i) { - depends2.push_back(depends[i]); + expand = depends[i]; + depends2.push_back(mf->ExpandVariablesInString(expand)); } - std::vector<std::string> outputs2; - for (i = 0; i < numOutputs; ++i) + + // Only one output is allowed. + const char* output = 0; + std::string outputStr; + if(numOutputs > 0) { - outputs2.push_back(outputs[i]); + expand = outputs[0]; + outputStr = mf->ExpandVariablesInString(expand); + output = outputStr.c_str(); } - mf->AddUtilityCommand(utilityName,command,arguments, (all ? true : false), - depends2, outputs2); + + // Pass the call to the makefile instance. + mf->AddUtilityCommand(utilityName, (all ? true : false), + output, depends2, commandLines); } void cmAddCustomCommand(void *arg, const char* source, const char* command, @@ -225,24 +249,42 @@ void cmAddCustomCommand(void *arg, const char* source, int numOutputs, const char **outputs, const char *target) { - cmMakefile *mf = static_cast<cmMakefile *>(arg); - int i; - std::vector<std::string> args2; - for (i = 0; i < numArgs; ++i) + // Get the makefile instance. Perform an extra variable expansion + // now because the API caller expects it. + cmMakefile* mf = static_cast<cmMakefile*>(arg); + + // Construct the command line for the command. + cmCustomCommandLine commandLine; + std::string expand = command; + commandLine.push_back(mf->ExpandVariablesInString(expand)); + for(int i=0; i < numArgs; ++i) { - args2.push_back(args[i]); + expand = args[i]; + commandLine.push_back(mf->ExpandVariablesInString(expand)); } + cmCustomCommandLines commandLines; + commandLines.push_back(commandLine); + + // Accumulate the list of dependencies. std::vector<std::string> depends2; - for (i = 0; i < numDepends; ++i) + for(int i = 0; i < numDepends; ++i) { - depends2.push_back(depends[i]); + expand = depends[i]; + depends2.push_back(mf->ExpandVariablesInString(expand)); } + + // Accumulate the list of outputs. std::vector<std::string> outputs2; - for (i = 0; i < numOutputs; ++i) + for(int i = 0; i < numOutputs; ++i) { - outputs2.push_back(outputs[i]); + expand = outputs[i]; + outputs2.push_back(mf->ExpandVariablesInString(expand)); } - mf->AddCustomCommand(source, command, args2, depends2, outputs2, target); + + // Pass the call to the makefile instance. + const char* no_comment = 0; + mf->AddCustomCommandOldStyle(target, outputs2, depends2, source, + commandLines, no_comment); } void cmAddCustomCommandToOutput(void *arg, const char* output, @@ -251,20 +293,34 @@ void cmAddCustomCommandToOutput(void *arg, const char* output, 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) + // Get the makefile instance. Perform an extra variable expansion + // now because the API caller expects it. + cmMakefile* mf = static_cast<cmMakefile*>(arg); + + // Construct the command line for the command. + cmCustomCommandLine commandLine; + std::string expand = command; + commandLine.push_back(mf->ExpandVariablesInString(expand)); + for(int i=0; i < numArgs; ++i) { - args2.push_back(args[i]); + expand = args[i]; + commandLine.push_back(mf->ExpandVariablesInString(expand)); } + cmCustomCommandLines commandLines; + commandLines.push_back(commandLine); + + // Accumulate the list of dependencies. std::vector<std::string> depends2; - for (i = 0; i < numDepends; ++i) + for(int i = 0; i < numDepends; ++i) { - depends2.push_back(depends[i]); + expand = depends[i]; + depends2.push_back(mf->ExpandVariablesInString(expand)); } - mf->AddCustomCommandToOutput(output, command, args2, main_dependency, - depends2); + + // Pass the call to the makefile instance. + const char* no_comment = 0; + mf->AddCustomCommandToOutput(output, depends2, main_dependency, + commandLines, no_comment); } void cmAddCustomCommandToTarget(void *arg, const char* target, @@ -272,28 +328,42 @@ void cmAddCustomCommandToTarget(void *arg, const char* target, 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) + // Get the makefile instance. + cmMakefile* mf = static_cast<cmMakefile*>(arg); + + // Construct the command line for the command. Perform an extra + // variable expansion now because the API caller expects it. + cmCustomCommandLine commandLine; + std::string expand = command; + commandLine.push_back(mf->ExpandVariablesInString(expand)); + for(int i=0; i < numArgs; ++i) { - args2.push_back(args[i]); + expand = args[i]; + commandLine.push_back(mf->ExpandVariablesInString(expand)); } + cmCustomCommandLines commandLines; + commandLines.push_back(commandLine); + + // Select the command type. + cmTarget::CustomCommandType cctype = cmTarget::POST_BUILD; switch (commandType) { case CM_PRE_BUILD: - mf->AddCustomCommandToTarget(target, command, args2, - cmTarget::PRE_BUILD); + cctype = cmTarget::PRE_BUILD; break; case CM_PRE_LINK: - mf->AddCustomCommandToTarget(target, command, args2, - cmTarget::PRE_LINK); + cctype = cmTarget::PRE_LINK; break; case CM_POST_BUILD: - mf->AddCustomCommandToTarget(target, command, args2, - cmTarget::POST_BUILD); + cctype = cmTarget::POST_BUILD; break; } + + // Pass the call to the makefile instance. + std::vector<std::string> no_depends; + const char* no_comment = 0; + mf->AddCustomCommandToTarget(target, no_depends, commandLines, + cctype, no_comment); } void cmAddLinkLibraryForTarget(void *arg, const char *tgt, const char*value, diff --git a/Source/cmCustomCommand.cxx b/Source/cmCustomCommand.cxx index fffa51d..d677798 100644 --- a/Source/cmCustomCommand.cxx +++ b/Source/cmCustomCommand.cxx @@ -9,74 +9,59 @@ Copyright (c) 2002 Kitware, Inc., Insight Consortium. All rights reserved. See Copyright.txt or http://www.cmake.org/HTML/Copyright.html for details. - This software is distributed WITHOUT ANY WARRANTY; without even - the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR + This software is distributed WITHOUT ANY WARRANTY; without even + the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "cmCustomCommand.h" -#include "cmMakefile.h" -/** - * The constructor - */ -cmCustomCommand::cmCustomCommand(const char *command, - const char* arguments, - std::vector<std::string> dep, - const char *out): - m_Command(command), - m_Arguments(arguments), - m_Depends(dep) +//---------------------------------------------------------------------------- +cmCustomCommand::cmCustomCommand() { - if (out) - { - m_Output = out; - } } -cmCustomCommand::cmCustomCommand(const char *command, - const char* arguments): - m_Command(command), - m_Arguments(arguments) +//---------------------------------------------------------------------------- +cmCustomCommand::cmCustomCommand(const cmCustomCommand& r): + m_Output(r.m_Output), + m_Depends(r.m_Depends), + m_CommandLines(r.m_CommandLines), + m_Comment(r.m_Comment) { } -/** - * Copy constructor. - */ -cmCustomCommand::cmCustomCommand(const cmCustomCommand& r): - m_Command(r.m_Command), - m_Arguments(r.m_Arguments), - m_Comment(r.m_Comment), - m_Output(r.m_Output), - m_Depends(r.m_Depends) +//---------------------------------------------------------------------------- +cmCustomCommand::cmCustomCommand(const char* output, + const std::vector<std::string>& depends, + const cmCustomCommandLines& commandLines, + const char* comment): + m_Output(output?output:""), + m_Depends(depends), + m_CommandLines(commandLines), + m_Comment(comment?comment:"") { } -void cmCustomCommand::ExpandVariables(const cmMakefile &mf) +//---------------------------------------------------------------------------- +const char* cmCustomCommand::GetOutput() const { - mf.ExpandVariablesInString(m_Command); - mf.ExpandVariablesInString(m_Arguments); - mf.ExpandVariablesInString(m_Output); + return m_Output.c_str(); +} - for (std::vector<std::string>::iterator i = m_Depends.begin(); - i != m_Depends.end(); ++i) - { - mf.ExpandVariablesInString(*i); - } +//---------------------------------------------------------------------------- +const std::vector<std::string>& cmCustomCommand::GetDepends() const +{ + return m_Depends; } +//---------------------------------------------------------------------------- +const cmCustomCommandLines& cmCustomCommand::GetCommandLines() const +{ + return m_CommandLines; +} -bool cmCustomCommand::IsEquivalent(const char* command, - const char* args) +//---------------------------------------------------------------------------- +const char* cmCustomCommand::GetComment() const { - if(m_Command != command) - { - return false; - } - if(m_Arguments != args) - { - return false; - } - return true; + return m_Comment.c_str(); } diff --git a/Source/cmCustomCommand.h b/Source/cmCustomCommand.h index 612780e..0a87949 100644 --- a/Source/cmCustomCommand.h +++ b/Source/cmCustomCommand.h @@ -9,8 +9,8 @@ Copyright (c) 2002 Kitware, Inc., Insight Consortium. All rights reserved. See Copyright.txt or http://www.cmake.org/HTML/Copyright.html for details. - This software is distributed WITHOUT ANY WARRANTY; without even - the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR + This software is distributed WITHOUT ANY WARRANTY; without even + the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ @@ -18,7 +18,6 @@ #define cmCustomCommand_h #include "cmStandardIncludes.h" -class cmMakefile; /** \class cmCustomCommand * \brief A class to encapsulate a custom command @@ -28,57 +27,33 @@ class cmMakefile; class cmCustomCommand { public: - cmCustomCommand(const char *command, - const char* arguments, - std::vector<std::string> dep, - const char *out); - cmCustomCommand(const char *command, - const char* arguments); - cmCustomCommand() {}; + /** Default and copy constructors for STL containers. */ + cmCustomCommand(); cmCustomCommand(const cmCustomCommand& r); - - /** - * Use the cmMakefile's Expand commands to expand any variables in - * this objects members. - */ - void ExpandVariables(const cmMakefile &); - ///! Return the command to execute with arguments - std::string GetCommandAndArguments() const - {return m_Command + " " + m_Arguments;} - - ///! Return the command to execute - const std::string &GetCommand() const {return m_Command;} - void SetCommand(const char *cmd) {m_Command = cmd;} + /** Main constructor specifies all information for the command. */ + cmCustomCommand(const char* output, + const std::vector<std::string>& depends, + const cmCustomCommandLines& commandLines, + const char* comment); - ///! Return the output - const std::string &GetOutput() const {return m_Output;} - void SetOutput(const char *cm) {m_Output = cm;} + /** Get the output file produced by the command. */ + const char* GetOutput() const; - ///! Return the comment - const std::string &GetComment() const {return m_Comment;} - void SetComment(const char *cm) {m_Comment = cm;} + /** Get the vector that holds the list of dependencies. */ + const std::vector<std::string>& GetDepends() const; + + /** Get the list of command lines. */ + const cmCustomCommandLines& GetCommandLines() const; + + /** Get the comment string for the command. */ + const char* GetComment() const; - ///! Return the commands arguments - const std::string &GetArguments() const {return m_Arguments;} - void SetArguments(const char *arg) {m_Arguments = arg;} - - /** - * Return the vector that holds the list of dependencies - */ - const std::vector<std::string> &GetDepends() const {return m_Depends;} - std::vector<std::string> &GetDepends() {return m_Depends;} - - ///! Return true if the command and args are equal to the ones here. - bool IsEquivalent(const char* command, - const char* args); private: - std::string m_Command; - std::string m_Arguments; - std::string m_Comment; std::string m_Output; std::vector<std::string> m_Depends; + cmCustomCommandLines m_CommandLines; + std::string m_Comment; }; - #endif diff --git a/Source/cmFLTKWrapUICommand.cxx b/Source/cmFLTKWrapUICommand.cxx index bdae514..6fda96e 100644 --- a/Source/cmFLTKWrapUICommand.cxx +++ b/Source/cmFLTKWrapUICommand.cxx @@ -29,7 +29,8 @@ bool cmFLTKWrapUICommand::InitialPass(std::vector<std::string> const& args) // what is the current source dir std::string cdir = m_Makefile->GetCurrentDirectory(); - std::string fluid_exe = "${FLTK_FLUID_EXECUTABLE}"; + const char* fluid_exe = + m_Makefile->GetRequiredDefinition("FLTK_FLUID_EXECUTABLE"); // get parameter for the command m_Target = args[0]; // Target that will use the generated files @@ -66,28 +67,28 @@ bool cmFLTKWrapUICommand::InitialPass(std::vector<std::string> const& args) std::string cxxres = outputDirectory.c_str(); cxxres += "/" + srcName; cxxres += ".cxx"; - - std::vector<std::string> cxxargs; - cxxargs.push_back("-c"); // instructs Fluid to run in command line - cxxargs.push_back("-h"); // optionally rename .h files - cxxargs.push_back(hname); - cxxargs.push_back("-o"); // optionally rename .cxx files - cxxargs.push_back(cxxres); - cxxargs.push_back(origname);// name of the GUI fluid file - + + cmCustomCommandLine commandLine; + commandLine.push_back(fluid_exe); + commandLine.push_back("-c"); // instructs Fluid to run in command line + commandLine.push_back("-h"); // optionally rename .h files + commandLine.push_back(hname); + commandLine.push_back("-o"); // optionally rename .cxx files + commandLine.push_back(cxxres); + commandLine.push_back(origname);// name of the GUI fluid file + cmCustomCommandLines commandLines; + commandLines.push_back(commandLine); + // Add command for generating the .h and .cxx files + const char* no_main_dependency = 0; + const char* no_comment = 0; m_Makefile->AddCustomCommandToOutput(cxxres.c_str(), - fluid_exe.c_str(), - cxxargs, - 0, - depends); - + depends, no_main_dependency, + commandLines, no_comment); m_Makefile->AddCustomCommandToOutput(hname.c_str(), - fluid_exe.c_str(), - cxxargs, - 0, - depends); - + depends, no_main_dependency, + commandLines, no_comment); + cmSourceFile *sf = m_Makefile->GetSource(cxxres.c_str()); sf->GetDepends().push_back(hname); sf->GetDepends().push_back(origname); diff --git a/Source/cmGlobalVisualStudio6Generator.cxx b/Source/cmGlobalVisualStudio6Generator.cxx index 7dd412d..34b4620 100644 --- a/Source/cmGlobalVisualStudio6Generator.cxx +++ b/Source/cmGlobalVisualStudio6Generator.cxx @@ -169,8 +169,9 @@ cmLocalGenerator *cmGlobalVisualStudio6Generator::CreateLocalGenerator() void cmGlobalVisualStudio6Generator::Generate() { // add a special target that depends on ALL projects for easy build - // of one configuration only. - std::vector<std::string> srcs; + // of one configuration only. + const char* no_output = 0; + std::vector<std::string> no_depends; std::map<cmStdString, std::vector<cmLocalGenerator*> >::iterator it; for(it = m_ProjectMap.begin(); it!= m_ProjectMap.end(); ++it) { @@ -179,12 +180,14 @@ void cmGlobalVisualStudio6Generator::Generate() if(gen.size()) { gen[0]->GetMakefile()-> - AddUtilityCommand("ALL_BUILD", "echo","\"Build all projects\"",false,srcs); + AddUtilityCommand("ALL_BUILD", false, no_output, no_depends, + "echo", "Build all projects"); std::string cmake_command = m_LocalGenerators[0]->GetMakefile()->GetRequiredDefinition("CMAKE_COMMAND"); gen[0]->GetMakefile()-> - AddUtilityCommand("INSTALL", cmake_command.c_str(), - "-DBUILD_TYPE=$(IntDir) -P cmake_install.cmake",false,srcs); + AddUtilityCommand("INSTALL", false, no_output, no_depends, + cmake_command.c_str(), + "-DBUILD_TYPE=$(IntDir)", "-P", "cmake_install.cmake"); } } @@ -277,8 +280,9 @@ void cmGlobalVisualStudio6Generator::WriteDSWFile(std::ostream& fout, if (strncmp(l->first.c_str(), "INCLUDE_EXTERNAL_MSPROJECT", 26) == 0) { cmCustomCommand cc = l->second.GetPostBuildCommands()[0]; - std::string project = cc.GetCommand(); - std::string location = cc.GetArguments(); + const cmCustomCommandLines& cmds = cc.GetCommandLines(); + std::string project = cmds[0][0]; + std::string location = cmds[0][1]; this->WriteExternalProject(fout, project.c_str(), location.c_str(), cc.GetDepends()); } else @@ -417,7 +421,8 @@ 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; + const char* no_output = 0; + std::vector<std::string> no_depends; std::map<cmStdString, std::vector<cmLocalGenerator*> >::iterator it; for(it = m_ProjectMap.begin(); it!= m_ProjectMap.end(); ++it) { @@ -426,7 +431,8 @@ void cmGlobalVisualStudio6Generator::SetupTests() if(gen.size()) { gen[0]->GetMakefile()-> - AddUtilityCommand("RUN_TESTS", ctest.c_str(), "-C $(IntDir)",false,srcs); + AddUtilityCommand("RUN_TESTS", false, no_output, no_depends, + ctest.c_str(), "-C", "$(IntDir)"); } } } diff --git a/Source/cmGlobalVisualStudio71Generator.cxx b/Source/cmGlobalVisualStudio71Generator.cxx index eee6a4b..35283df 100644 --- a/Source/cmGlobalVisualStudio71Generator.cxx +++ b/Source/cmGlobalVisualStudio71Generator.cxx @@ -120,11 +120,10 @@ void cmGlobalVisualStudio71Generator::WriteSLNFile(std::ostream& fout, if (strncmp(l->first.c_str(), "INCLUDE_EXTERNAL_MSPROJECT", 26) == 0) { cmCustomCommand cc = l->second.GetPostBuildCommands()[0]; - - std::string project = cc.GetCommand(); - std::string location = cc.GetArguments(); - this->WriteExternalProject(fout, project.c_str(), - location.c_str(), cc.GetDepends()); + const cmCustomCommandLines& cmds = cc.GetCommandLines(); + std::string project = cmds[0][0]; + std::string location = cmds[0][1]; + this->WriteExternalProject(fout, project.c_str(), location.c_str(), cc.GetDepends()); } else { @@ -204,8 +203,8 @@ void cmGlobalVisualStudio71Generator::WriteSLNFile(std::ostream& fout, if (strncmp(l->first.c_str(), "INCLUDE_EXTERNAL_MSPROJECT", 26) == 0) { cmCustomCommand cc = l->second.GetPostBuildCommands()[0]; - std::string project = cc.GetCommand(); - + const cmCustomCommandLines& cmds = cc.GetCommandLines(); + std::string project = cmds[0][0]; this->WriteProjectConfigurations(fout, project.c_str(), l->second.IsInAll()); } else if ((l->second.GetType() != cmTarget::INSTALL_FILES) diff --git a/Source/cmGlobalVisualStudio7Generator.cxx b/Source/cmGlobalVisualStudio7Generator.cxx index 70a8c197..2fda9de 100644 --- a/Source/cmGlobalVisualStudio7Generator.cxx +++ b/Source/cmGlobalVisualStudio7Generator.cxx @@ -167,7 +167,8 @@ 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; + const char* no_output = 0; + std::vector<std::string> no_depends; std::map<cmStdString, std::vector<cmLocalGenerator*> >::iterator it; for(it = m_ProjectMap.begin(); it!= m_ProjectMap.end(); ++it) { @@ -176,7 +177,8 @@ void cmGlobalVisualStudio7Generator::SetupTests() if(gen.size()) { gen[0]->GetMakefile()-> - AddUtilityCommand("RUN_TESTS", ctest.c_str(), "-C $(IntDir)",false,srcs); + AddUtilityCommand("RUN_TESTS", false, no_output, no_depends, + ctest.c_str(), "-C", "$(IntDir)"); } } } @@ -254,8 +256,9 @@ void cmGlobalVisualStudio7Generator::GenerateConfigurations(cmMakefile* mf) void cmGlobalVisualStudio7Generator::Generate() { // add a special target that depends on ALL projects for easy build - // of Debug only - std::vector<std::string> srcs; + // of one configuration only. + const char* no_output = 0; + std::vector<std::string> no_depends; std::map<cmStdString, std::vector<cmLocalGenerator*> >::iterator it; for(it = m_ProjectMap.begin(); it!= m_ProjectMap.end(); ++it) { @@ -264,12 +267,14 @@ void cmGlobalVisualStudio7Generator::Generate() if(gen.size()) { gen[0]->GetMakefile()-> - AddUtilityCommand("ALL_BUILD", "echo","\"Build all projects\"",false,srcs); + AddUtilityCommand("ALL_BUILD", false, no_output, no_depends, + "echo", "Build all projects"); std::string cmake_command = m_LocalGenerators[0]->GetMakefile()->GetRequiredDefinition("CMAKE_COMMAND"); gen[0]->GetMakefile()-> - AddUtilityCommand("INSTALL", cmake_command.c_str(), - "-DBUILD_TYPE=$(IntDir) -P cmake_install.cmake",false,srcs); + AddUtilityCommand("INSTALL", false, no_output, no_depends, + cmake_command.c_str(), + "-DBUILD_TYPE=$(IntDir)", "-P", "cmake_install.cmake"); } } @@ -394,11 +399,10 @@ void cmGlobalVisualStudio7Generator::WriteSLNFile(std::ostream& fout, if (strncmp(l->first.c_str(), "INCLUDE_EXTERNAL_MSPROJECT", 26) == 0) { cmCustomCommand cc = l->second.GetPostBuildCommands()[0]; - - std::string project_name = cc.GetCommand(); - std::string location = cc.GetArguments(); - this->WriteExternalProject(fout, project_name.c_str(), - location.c_str(), cc.GetDepends()); + const cmCustomCommandLines& cmds = cc.GetCommandLines(); + std::string project = cmds[0][0]; + std::string location = cmds[0][1]; + this->WriteExternalProject(fout, project.c_str(), location.c_str(), cc.GetDepends()); } else { @@ -481,7 +485,8 @@ void cmGlobalVisualStudio7Generator::WriteSLNFile(std::ostream& fout, if (strncmp(l->first.c_str(), "INCLUDE_EXTERNAL_MSPROJECT", 26) == 0) { cmCustomCommand cc = l->second.GetPostBuildCommands()[0]; - std::string name = cc.GetCommand(); + const cmCustomCommandLines& cmds = cc.GetCommandLines(); + std::string name = cmds[0][0]; std::vector<std::string> depends = cc.GetDepends(); std::vector<std::string>::iterator iter; int depcount = 0; @@ -522,7 +527,8 @@ void cmGlobalVisualStudio7Generator::WriteSLNFile(std::ostream& fout, if(strncmp(l->first.c_str(), "INCLUDE_EXTERNAL_MSPROJECT", 26) == 0) { cmCustomCommand cc = l->second.GetPostBuildCommands()[0]; - std::string name = cc.GetCommand(); + const cmCustomCommandLines& cmds = cc.GetCommandLines(); + std::string name = cmds[0][0]; this->WriteProjectConfigurations(fout, name.c_str(), l->second.IsInAll()); } else if ((l->second.GetType() != cmTarget::INSTALL_FILES) diff --git a/Source/cmGlobalXCodeGenerator.cxx b/Source/cmGlobalXCodeGenerator.cxx index 484ac1e..cf37483 100644 --- a/Source/cmGlobalXCodeGenerator.cxx +++ b/Source/cmGlobalXCodeGenerator.cxx @@ -207,16 +207,18 @@ void cmGlobalXCodeGenerator::AddExtraTargets(cmLocalGenerator* root, std::vector<cmLocalGenerator*>& gens) { - std::vector<std::string> srcs; // dummy list cmMakefile* mf = root->GetMakefile(); // Add ALL_BUILD - mf->AddUtilityCommand("ALL_BUILD", "echo", - "\"Build all projects\"",false,srcs); + const char* no_output = 0; + std::vector<std::string> no_depends; + mf->AddUtilityCommand("ALL_BUILD", false, no_output, no_depends, + "echo", "Build all projects"); cmTarget* allbuild = mf->FindTarget("ALL_BUILD"); // ADD install std::string cmake_command = mf->GetRequiredDefinition("CMAKE_COMMAND"); - mf->AddUtilityCommand("install", cmake_command.c_str(), - "-P cmake_install.cmake",false,srcs); + mf->AddUtilityCommand("install", false, no_output, no_depends, + cmake_command.c_str(), + "-P", "cmake_install.cmake"); // Add RUN_TESTS target if testing has been enabled std::string fname; fname = mf->GetStartOutputDirectory(); @@ -226,11 +228,9 @@ cmGlobalXCodeGenerator::AddExtraTargets(cmLocalGenerator* root, { std::string ctest_command = mf->GetRequiredDefinition("CMAKE_CTEST_COMMAND"); - mf->AddUtilityCommand("RUN_TESTS", ctest_command.c_str(), "",false,srcs); + mf->AddUtilityCommand("RUN_TESTS", false, no_output, no_depends, + ctest_command.c_str()); } - // Add install - mf->AddUtilityCommand("install", cmake_command.c_str(), - "-P cmake_install.cmake", false, srcs); // Add XCODE depend helper std::string dir = mf->GetCurrentOutputDirectory(); m_CurrentXCodeHackMakefile = dir; @@ -242,9 +242,8 @@ cmGlobalXCodeGenerator::AddExtraTargets(cmLocalGenerator* root, makecommand += " -f "; makecommand += this->ConvertToRelativeOutputPath( m_CurrentXCodeHackMakefile.c_str()); - mf->AddUtilityCommand("XCODE_DEPEND_HELPER", makecommand.c_str(), - "", - false,srcs); + mf->AddUtilityCommand("XCODE_DEPEND_HELPER", false, no_output, no_depends, + makecommand.c_str()); // now make the allbuild depend on all the non-utility targets // in the project for(std::vector<cmLocalGenerator*>::iterator i = gens.begin(); @@ -656,12 +655,12 @@ cmGlobalXCodeGenerator::AddCommandsToBuildPhase(cmXCodeObject* buildphase, i != commands.end(); ++i) { cmCustomCommand const& cc = *i; - if(cc.GetCommand().size()) + if(!cc.GetCommandLines().empty()) { - if(cc.GetOutput().size()) + if(cc.GetOutput()[0]) { makefileStream << "\\\n\t" << this-> - ConvertToRelativeOutputPath(cc.GetOutput().c_str()); + ConvertToRelativeOutputPath(cc.GetOutput()); } else { @@ -677,15 +676,15 @@ cmGlobalXCodeGenerator::AddCommandsToBuildPhase(cmXCodeObject* buildphase, i != commands.end(); ++i) { cmCustomCommand const& cc = *i; - if(cc.GetCommand().size()) + if(!cc.GetCommandLines().empty()) { makefileStream << "\n#" << "Custom command rule: " << cc.GetComment() << "\n"; - if(cc.GetOutput().size()) + if(cc.GetOutput()[0]) { makefileStream << this - ->ConvertToRelativeOutputPath(cc.GetOutput().c_str()) << ": "; + ->ConvertToRelativeOutputPath(cc.GetOutput()) << ": "; } else { @@ -707,8 +706,23 @@ cmGlobalXCodeGenerator::AddCommandsToBuildPhase(cmXCodeObject* buildphase, } } makefileStream << "\n"; - makefileStream << "\t" << cc.GetCommand() << " " - << cc.GetArguments() << "\n"; + + // Add each command line to the set of commands. + for(cmCustomCommandLines::const_iterator cl = cc.GetCommandLines().begin(); + cl != cc.GetCommandLines().end(); ++cl) + { + // Build the command line in a single string. + const cmCustomCommandLine& commandLine = *cl; + std::string cmd = commandLine[0]; + cmSystemTools::ReplaceString(cmd, "/./", "/"); + cmd = this->ConvertToRelativeOutputPath(cmd.c_str()); + for(unsigned int j=1; j < commandLine.size(); ++j) + { + cmd += " "; + cmd += cmSystemTools::EscapeSpaces(commandLine[j].c_str()); + } + makefileStream << "\t" << cmd.c_str() << "\n"; + } } } std::string cdir = m_CurrentMakefile->GetCurrentOutputDirectory(); diff --git a/Source/cmITKWrapTclCommand.cxx b/Source/cmITKWrapTclCommand.cxx index 8bbb11a..3f10e10 100644 --- a/Source/cmITKWrapTclCommand.cxx +++ b/Source/cmITKWrapTclCommand.cxx @@ -104,23 +104,24 @@ bool cmITKWrapTclCommand::CreateCableRule(const char* configFile) { depends.push_back(command); } - - std::vector<std::string> commandArgs; - commandArgs.push_back(inFile); - commandArgs.push_back("-tcl"); + + cmCustomCommandLine commandLine; + commandLine.push_back(command); + commandLine.push_back(inFile); + commandLine.push_back("-tcl"); std::string tmp = tclFile+".cxx"; - commandArgs.push_back(tmp); + commandLine.push_back(tmp); #if !defined(_WIN32) || defined(__CYGWIN__) tmp = "${CMAKE_CXX_COMPILER}"; m_Makefile->ExpandVariablesInString(tmp); if(tmp.length() > 0) { - commandArgs.push_back("--gccxml-compiler"); - commandArgs.push_back(tmp); + commandLine.push_back("--gccxml-compiler"); + commandLine.push_back(tmp); tmp = "${CMAKE_CXX_FLAGS}"; m_Makefile->ExpandVariablesInString(tmp); - commandArgs.push_back("--gccxml-cxxflags"); - commandArgs.push_back(tmp); + commandLine.push_back("--gccxml-cxxflags"); + commandLine.push_back(tmp); } #else const char* genName = m_Makefile->GetDefinition("CMAKE_GENERATOR"); @@ -129,44 +130,44 @@ bool cmITKWrapTclCommand::CreateCableRule(const char* configFile) std::string gen = genName; if(gen == "Visual Studio 6") { - commandArgs.push_back("--gccxml-compiler"); - commandArgs.push_back("msvc6"); + commandLine.push_back("--gccxml-compiler"); + commandLine.push_back("msvc6"); tmp = "${CMAKE_CXX_FLAGS}"; m_Makefile->ExpandVariablesInString(tmp); - commandArgs.push_back("--gccxml-cxxflags"); - commandArgs.push_back(tmp); + commandLine.push_back("--gccxml-cxxflags"); + commandLine.push_back(tmp); } else if(gen == "Visual Studio 7") { - commandArgs.push_back("--gccxml-compiler"); - commandArgs.push_back("msvc7"); + commandLine.push_back("--gccxml-compiler"); + commandLine.push_back("msvc7"); tmp = "${CMAKE_CXX_FLAGS}"; m_Makefile->ExpandVariablesInString(tmp); - commandArgs.push_back("--gccxml-cxxflags"); - commandArgs.push_back(tmp); + commandLine.push_back("--gccxml-cxxflags"); + commandLine.push_back(tmp); } else if(gen == "NMake Makefiles") { tmp = "${CMAKE_CXX_COMPILER}"; m_Makefile->ExpandVariablesInString(tmp); - commandArgs.push_back("--gccxml-compiler"); - commandArgs.push_back(tmp); + commandLine.push_back("--gccxml-compiler"); + commandLine.push_back(tmp); tmp = "${CMAKE_CXX_FLAGS}"; m_Makefile->ExpandVariablesInString(tmp); - commandArgs.push_back("--gccxml-cxxflags"); - commandArgs.push_back(tmp); + commandLine.push_back("--gccxml-cxxflags"); + commandLine.push_back(tmp); } } #endif const char* gccxml = m_Makefile->GetDefinition("ITK_GCCXML_EXECUTABLE"); if(gccxml) { - commandArgs.push_back("--gccxml"); - commandArgs.push_back(gccxml); + commandLine.push_back("--gccxml"); + commandLine.push_back(gccxml); } tmp = "-I"; tmp += m_Makefile->GetStartDirectory(); - commandArgs.push_back(tmp); + commandLine.push_back(tmp); const std::vector<std::string>& includes = m_Makefile->GetIncludeDirectories(); for(std::vector<std::string>::const_iterator i = includes.begin(); @@ -175,7 +176,7 @@ bool cmITKWrapTclCommand::CreateCableRule(const char* configFile) tmp = "-I"; tmp += i->c_str(); m_Makefile->ExpandVariablesInString(tmp); - commandArgs.push_back(tmp); + commandLine.push_back(tmp); } // Get the dependencies. @@ -198,11 +199,12 @@ bool cmITKWrapTclCommand::CreateCableRule(const char* configFile) file.GetDepends().push_back("CableTclFacility/ctCalls.h"); m_Makefile->AddSource(file); - m_Makefile->AddCustomCommandToOutput(output.c_str(), - command.c_str(), - commandArgs, - inFile.c_str(), - depends); + const char* no_comment = 0; + cmCustomCommandLines commandLines; + commandLines.push_back(commandLine); + m_Makefile->AddCustomCommandToOutput(output.c_str(), depends, + inFile.c_str(), commandLines, + no_comment); // Add the generated source to the package's source list. m_Target->GetSourceLists().push_back(output); diff --git a/Source/cmIncludeExternalMSProjectCommand.cxx b/Source/cmIncludeExternalMSProjectCommand.cxx index 7e87dad..ad3f94c 100644 --- a/Source/cmIncludeExternalMSProjectCommand.cxx +++ b/Source/cmIncludeExternalMSProjectCommand.cxx @@ -42,9 +42,11 @@ bool cmIncludeExternalMSProjectCommand::InitialPass(std::vector<std::string> con std::string utility_name("INCLUDE_EXTERNAL_MSPROJECT"); utility_name += "_"; utility_name += args[0]; - - m_Makefile->AddUtilityCommand(utility_name.c_str(), args[0].c_str(), args[1].c_str(), - true, depends); + + const char* no_output = 0; + m_Makefile->AddUtilityCommand(utility_name.c_str(), true, + no_output, depends, + args[0].c_str(), args[1].c_str()); } #endif diff --git a/Source/cmLocalGenerator.cxx b/Source/cmLocalGenerator.cxx index b505712..2faf647 100644 --- a/Source/cmLocalGenerator.cxx +++ b/Source/cmLocalGenerator.cxx @@ -509,6 +509,7 @@ void cmLocalGenerator::AddCustomCommandToCreateObject(const char* ofname, sourceAndDeps.push_back(this->ConvertToRelativeOutputPath(i->c_str())); } } +#if 0 std::string command; std::string args; cmSystemTools::SplitProgramFromArgs(commands[0].c_str(), command, args); @@ -520,6 +521,7 @@ void cmLocalGenerator::AddCustomCommandToCreateObject(const char* ofname, source.GetFullPath().c_str(), sourceAndDeps, "build from source"); +#endif } void cmLocalGenerator::AddBuildTargetRule(const char* llang, cmTarget& target) @@ -577,13 +579,16 @@ void cmLocalGenerator::AddBuildTargetRule(const char* llang, cmTarget& target) 0, // target so name, linkFlags.c_str() // link flags ); +#if 0 std::string command; std::string args; cmSystemTools::SplitProgramFromArgs(rule.c_str(), command, args); // Just like ADD_CUSTOM_TARGET(foo ALL DEPENDS a.o b.o) // Add a custom command for generating each .o file - cmCustomCommand cc(command.c_str(), args.c_str(), objVector, targetName.c_str()); + cmCustomCommand cc(command.c_str(), args.c_str(), objVector, + targetName.c_str(), 0); target.GetPostBuildCommands().push_back(cc); +#endif } @@ -1342,3 +1347,31 @@ void cmLocalGenerator::AppendFlags(std::string& flags, } } +//---------------------------------------------------------------------------- +std::string +cmLocalGenerator::ConstructScript(const cmCustomCommandLines& commandLines, + const char* newline) +{ + // Store the script in a string. + std::string script; + + // Write each command on a single line. + for(cmCustomCommandLines::const_iterator cl = commandLines.begin(); + cl != commandLines.end(); ++cl) + { + // Start with the command name. + const cmCustomCommandLine& commandLine = *cl; + script += this->ConvertToRelativeOutputPath(commandLine[0].c_str()); + + // Add the arguments. + for(unsigned int j=1;j < commandLine.size(); ++j) + { + script += " "; + script += cmSystemTools::EscapeSpaces(commandLine[j].c_str()); + } + + // End the line. + script += newline; + } + return script; +} diff --git a/Source/cmLocalGenerator.h b/Source/cmLocalGenerator.h index 2307c14..8dea2d5 100644 --- a/Source/cmLocalGenerator.h +++ b/Source/cmLocalGenerator.h @@ -105,6 +105,9 @@ public: protected: + /** Construct a script from the given list of command lines. */ + std::string ConstructScript(const cmCustomCommandLines& commandLines, + const char* newline = "\n"); ///! Fill out these strings for the given target. Libraries to link, flags, and linkflags. void GetTargetFlags(std::string& linkLibs, diff --git a/Source/cmLocalUnixMakefileGenerator.cxx b/Source/cmLocalUnixMakefileGenerator.cxx index 0236d74..9a881cc 100644 --- a/Source/cmLocalUnixMakefileGenerator.cxx +++ b/Source/cmLocalUnixMakefileGenerator.cxx @@ -663,8 +663,6 @@ std::string cmLocalUnixMakefileGenerator::CreatePreBuildRules( target.GetPreBuildCommands().begin(); cr != target.GetPreBuildCommands().end(); ++cr) { - cmCustomCommand cc(*cr); - cc.ExpandVariables(*m_Makefile); if(initNext) { customRuleCode += "\n\t"; @@ -673,8 +671,7 @@ std::string cmLocalUnixMakefileGenerator::CreatePreBuildRules( { initNext = true; } - std::string command = this->ConvertToRelativeOutputPath(cc.GetCommand().c_str()); - customRuleCode += command + " " + cc.GetArguments(); + customRuleCode += this->ConstructScript(cr->GetCommandLines(), "\n\t"); } return customRuleCode; } @@ -688,8 +685,6 @@ std::string cmLocalUnixMakefileGenerator::CreatePreLinkRules( target.GetPreLinkCommands().begin(); cr != target.GetPreLinkCommands().end(); ++cr) { - cmCustomCommand cc(*cr); - cc.ExpandVariables(*m_Makefile); if(initNext) { customRuleCode += "\n\t"; @@ -698,8 +693,7 @@ std::string cmLocalUnixMakefileGenerator::CreatePreLinkRules( { initNext = true; } - std::string command = this->ConvertToRelativeOutputPath(cc.GetCommand().c_str()); - customRuleCode += command + " " + cc.GetArguments(); + customRuleCode += this->ConstructScript(cr->GetCommandLines(), "\n\t"); } return customRuleCode; } @@ -713,8 +707,6 @@ std::string cmLocalUnixMakefileGenerator::CreatePostBuildRules( target.GetPostBuildCommands().begin(); cr != target.GetPostBuildCommands().end(); ++cr) { - cmCustomCommand cc(*cr); - cc.ExpandVariables(*m_Makefile); if(initNext) { customRuleCode += "\n\t"; @@ -723,8 +715,7 @@ std::string cmLocalUnixMakefileGenerator::CreatePostBuildRules( { initNext = true; } - std::string command = this->ConvertToRelativeOutputPath(cc.GetCommand().c_str()); - customRuleCode += command + " " + cc.GetArguments(); + customRuleCode += this->ConstructScript(cr->GetCommandLines(), "\n\t"); } return customRuleCode; } @@ -2025,12 +2016,24 @@ void cmLocalUnixMakefileGenerator::OutputCustomRules(std::ostream& fout) // escape spaces and convert to native slashes path for // the command std::string comment = c->GetComment(); - std::string command = c->GetCommand(); - cmSystemTools::ReplaceString(command, "/./", "/"); - command = this->ConvertToRelativeOutputPath(command.c_str()); - command += " "; - // now add the arguments - command += c->GetArguments(); + std::vector<std::string> commands; + + // Add each command line to the set of commands. + for(cmCustomCommandLines::const_iterator cl = c->GetCommandLines().begin(); + cl != c->GetCommandLines().end(); ++cl) + { + // Build the command line in a single string. + const cmCustomCommandLine& commandLine = *cl; + std::string cmd = commandLine[0]; + cmSystemTools::ReplaceString(cmd, "/./", "/"); + cmd = this->ConvertToRelativeOutputPath(cmd.c_str()); + for(unsigned int j=1; j < commandLine.size(); ++j) + { + cmd += " "; + cmd += cmSystemTools::EscapeSpaces(commandLine[j].c_str()); + } + commands.push_back(cmd); + } std::vector<std::string> depends; // Collect out all the dependencies for this rule. for(std::vector<std::string>::const_iterator d = @@ -2066,15 +2069,15 @@ void cmLocalUnixMakefileGenerator::OutputCustomRules(std::ostream& fout) { this->OutputMakeRule(fout, (comment.size()?comment.c_str():"Custom command"), - c->GetOutput().c_str(), + c->GetOutput(), depends, - command.c_str()); + commands); 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()); + c->GetOutput()); } } } diff --git a/Source/cmLocalUnixMakefileGenerator2.cxx b/Source/cmLocalUnixMakefileGenerator2.cxx index 57ff0c9..400c3be 100644 --- a/Source/cmLocalUnixMakefileGenerator2.cxx +++ b/Source/cmLocalUnixMakefileGenerator2.cxx @@ -670,7 +670,7 @@ cmLocalUnixMakefileGenerator2 if(m_CustomRuleFiles.find(ruleFileName) != m_CustomRuleFiles.end()) { cmSystemTools::Error("An output was found with multiple rules on how to build it for output: ", - cc.GetOutput().c_str()); + cc.GetOutput()); return; } m_CustomRuleFiles.insert(ruleFileName); @@ -704,15 +704,15 @@ cmLocalUnixMakefileGenerator2 // Write the rule. const char* comment = 0; - if(cc.GetComment().size()) + if(cc.GetComment() && *cc.GetComment()) { - comment = cc.GetComment().c_str(); + comment = cc.GetComment(); } std::string preEcho = "Generating "; preEcho += customName; preEcho += "..."; this->WriteMakeRule(ruleFileStream, comment, preEcho.c_str(), - cc.GetOutput().c_str(), depends, commands); + cc.GetOutput(), depends, commands); // Write the clean rule for this custom command. std::string cleanTarget = customName; @@ -720,7 +720,7 @@ cmLocalUnixMakefileGenerator2 commands.clear(); depends.clear(); std::vector<std::string> cleanFiles; - cleanFiles.push_back(cc.GetOutput().c_str()); + cleanFiles.push_back(cc.GetOutput()); this->AppendCleanCommand(commands, cleanFiles); this->WriteMakeRule(ruleFileStream, "Clean the output of this custom command.", 0, @@ -2282,18 +2282,18 @@ cmLocalUnixMakefileGenerator2 // the custom file. Otherwise, we will use just the filename // portion. std::string customName; - if(cmSystemTools::FileIsFullPath(cc.GetOutput().c_str()) && - (cc.GetOutput().find(m_Makefile->GetStartOutputDirectory()) == 0)) + if(cmSystemTools::FileIsFullPath(cc.GetOutput()) && + (std::string(cc.GetOutput()).find(m_Makefile->GetStartOutputDirectory()) == 0)) { // Use the relative path but convert it to a valid file name. customName = cmSystemTools::RelativePath(m_Makefile->GetStartOutputDirectory(), - cc.GetOutput().c_str()); + cc.GetOutput()); cmSystemTools::ReplaceString(customName, "/", "_"); } else { - customName = cmSystemTools::GetFilenameName(cc.GetOutput().c_str()); + customName = cmSystemTools::GetFilenameName(cc.GetOutput()); } return customName; } @@ -2734,16 +2734,22 @@ cmLocalUnixMakefileGenerator2 { // TODO: Convert outputs/dependencies (arguments?) to relative paths. - // Build the command line in a single string. - std::string cmd = cc.GetCommand(); - cmSystemTools::ReplaceString(cmd, "/./", "/"); - cmd = this->ConvertToRelativeOutputPath(cmd.c_str()); - if(cc.GetArguments().size() > 0) + // Add each command line to the set of commands. + for(cmCustomCommandLines::const_iterator cl = cc.GetCommandLines().begin(); + cl != cc.GetCommandLines().end(); ++cl) { - cmd += " "; - cmd += cc.GetArguments(); + // Build the command line in a single string. + const cmCustomCommandLine& commandLine = *cl; + std::string cmd = commandLine[0]; + cmSystemTools::ReplaceString(cmd, "/./", "/"); + cmd = this->ConvertToRelativeOutputPath(cmd.c_str()); + for(unsigned int j=1; j < commandLine.size(); ++j) + { + cmd += " "; + cmd += cmSystemTools::EscapeSpaces(commandLine[j].c_str()); + } + commands.push_back(cmd); } - commands.push_back(cmd); } //---------------------------------------------------------------------------- diff --git a/Source/cmLocalVisualStudio6Generator.cxx b/Source/cmLocalVisualStudio6Generator.cxx index 95e46b8..8363f58 100644 --- a/Source/cmLocalVisualStudio6Generator.cxx +++ b/Source/cmLocalVisualStudio6Generator.cxx @@ -81,9 +81,6 @@ 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(); @@ -170,11 +167,10 @@ void cmLocalVisualStudio6Generator::AddDSPBuildRule() makefileIn += "/"; makefileIn += "CMakeLists.txt"; makefileIn = this->ConvertToRelativeOutputPath(makefileIn.c_str()); - std::string dsprule = "${CMAKE_COMMAND}"; - m_Makefile->ExpandVariablesInString(dsprule); - dsprule = this->ConvertToRelativeOutputPath(dsprule.c_str()); - std::vector<std::string> argv; - argv.push_back(makefileIn); + const char* dsprule = m_Makefile->GetRequiredDefinition("CMAKE_COMMAND"); + cmCustomCommandLine commandLine; + commandLine.push_back(dsprule); + commandLine.push_back(makefileIn); makefileIn = m_Makefile->GetStartDirectory(); makefileIn += "/"; makefileIn += "CMakeLists.txt"; @@ -182,11 +178,11 @@ void cmLocalVisualStudio6Generator::AddDSPBuildRule() args = "-H"; args += this->ConvertToRelativeOutputPath(m_Makefile->GetHomeDirectory()); - argv.push_back(args); + commandLine.push_back(args); args = "-B"; args += this->ConvertToRelativeOutputPath(m_Makefile->GetHomeOutputDirectory()); - argv.push_back(args); + commandLine.push_back(args); std::string configFile = m_Makefile->GetRequiredDefinition("CMAKE_ROOT"); @@ -205,9 +201,12 @@ void cmLocalVisualStudio6Generator::AddDSPBuildRule() { listFiles.push_back(configFile); } - m_Makefile->AddCustomCommandToOutput(dspname.c_str(), dsprule.c_str(), - argv, makefileIn.c_str(), listFiles, - NULL, true); + + cmCustomCommandLines commandLines; + commandLines.push_back(commandLine); + const char* no_comment = 0; + m_Makefile->AddCustomCommandToOutput(dspname.c_str(), listFiles, makefileIn.c_str(), + commandLines, no_comment, true); } @@ -234,26 +233,19 @@ void cmLocalVisualStudio6Generator::WriteDSPFile(std::ostream& fout, target.GetPostBuildCommands().begin(); cr != target.GetPostBuildCommands().end(); ++cr) { - cmCustomCommand cc(*cr); - cc.ExpandVariables(*m_Makefile); char *output = new char [ strlen(m_Makefile->GetStartOutputDirectory()) + strlen(libName) + 30]; sprintf(output,"%s/%s_force_%i", m_Makefile->GetStartOutputDirectory(), libName, count); - std::vector<std::string> args; - // This is a hack to fix a problem with cmCustomCommand - // The cmCustomCommand should store the arguments as a vector - // and not a string, and the cmAddCustomTargetCommand should - // not EscapeSpaces. - args.push_back("This is really a single argument do not escape spaces"); - args.push_back(cc.GetArguments()); - m_Makefile->AddCustomCommandToOutput(output, - cc.GetCommand().c_str(), - args, - 0, - cc.GetDepends()); + const char* no_main_dependency = 0; + const char* no_comment = 0; + m_Makefile->AddCustomCommandToOutput(output, + cr->GetDepends(), + no_main_dependency, + cr->GetCommandLines(), + no_comment); cmSourceFile* outsf = m_Makefile->GetSourceFileWithOutput(output); target.GetSourceFiles().push_back(outsf); @@ -380,18 +372,13 @@ void cmLocalVisualStudio6Generator::WriteDSPFile(std::ostream& fout, } if (command) { - std::string totalCommandStr; - totalCommandStr = - this->ConvertToRelativeOutputPath(command->GetCommand().c_str()); - totalCommandStr += " "; - totalCommandStr += command->GetArguments(); - totalCommandStr += "\n"; - const char* comment = command->GetComment().c_str(); + std::string script = this->ConstructScript(command->GetCommandLines()); + const char* comment = command->GetComment(); const char* flags = compileFlags.size() ? compileFlags.c_str(): 0; - this->WriteCustomRule(fout, source.c_str(), totalCommandStr.c_str(), + this->WriteCustomRule(fout, source.c_str(), script.c_str(), (*comment?comment:"Custom Rule"), command->GetDepends(), - command->GetOutput().c_str(), flags); + command->GetOutput(), flags); } else if(compileFlags.size()) { @@ -635,8 +622,6 @@ cmLocalVisualStudio6Generator::CreateTargetRules(const cmTarget &target, target.GetPreBuildCommands().begin(); cr != target.GetPreBuildCommands().end(); ++cr) { - cmCustomCommand cc(*cr); - cc.ExpandVariables(*m_Makefile); if (!init) { // header stuff @@ -647,15 +632,13 @@ cmLocalVisualStudio6Generator::CreateTargetRules(const cmTarget &target, { customRuleCode += "\\\n\t"; } - customRuleCode += this->ConvertToRelativeOutputPath(cc.GetCommand().c_str()) + " " + cc.GetArguments(); + customRuleCode += this->ConstructScript(cr->GetCommandLines(), "\\\n\t"); } 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 @@ -666,7 +649,7 @@ cmLocalVisualStudio6Generator::CreateTargetRules(const cmTarget &target, { customRuleCode += "\\\n\t"; } - customRuleCode += this->ConvertToRelativeOutputPath(cc.GetCommand().c_str()) + " " + cc.GetArguments(); + customRuleCode += this->ConstructScript(cr->GetCommandLines(), "\\\n\t"); } // do the post build rules @@ -675,8 +658,6 @@ cmLocalVisualStudio6Generator::CreateTargetRules(const cmTarget &target, target.GetPostBuildCommands().begin(); cr != target.GetPostBuildCommands().end(); ++cr) { - cmCustomCommand cc(*cr); - cc.ExpandVariables(*m_Makefile); if (!init) { // header stuff @@ -687,9 +668,7 @@ cmLocalVisualStudio6Generator::CreateTargetRules(const cmTarget &target, { customRuleCode += "\\\n\t"; } - customRuleCode += - this->ConvertToRelativeOutputPath(cc.GetCommand().c_str()) + - " " + cc.GetArguments(); + customRuleCode += this->ConstructScript(cr->GetCommandLines(), "\\\n\t"); } customRuleCode += "\n# End Special Build Tool\n"; diff --git a/Source/cmLocalVisualStudio7Generator.cxx b/Source/cmLocalVisualStudio7Generator.cxx index 06d12f1..8ebf4da 100644 --- a/Source/cmLocalVisualStudio7Generator.cxx +++ b/Source/cmLocalVisualStudio7Generator.cxx @@ -89,9 +89,6 @@ 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(); @@ -142,11 +139,10 @@ void cmLocalVisualStudio7Generator::AddVCProjBuildRule() makefileIn += "/"; makefileIn += "CMakeLists.txt"; makefileIn = this->ConvertToRelativeOutputPath(makefileIn.c_str()); - std::string dsprule = "${CMAKE_COMMAND}"; - m_Makefile->ExpandVariablesInString(dsprule); - dsprule = this->ConvertToRelativeOutputPath(dsprule.c_str()); - std::vector<std::string> argv; - argv.push_back(makefileIn); + const char* dsprule = m_Makefile->GetRequiredDefinition("CMAKE_COMMAND"); + cmCustomCommandLine commandLine; + commandLine.push_back(dsprule); + commandLine.push_back(makefileIn); makefileIn = m_Makefile->GetStartDirectory(); makefileIn += "/"; makefileIn += "CMakeLists.txt"; @@ -154,11 +150,11 @@ void cmLocalVisualStudio7Generator::AddVCProjBuildRule() args = "-H"; args += this->ConvertToRelativeOutputPath(m_Makefile->GetHomeDirectory()); - argv.push_back(args); + commandLine.push_back(args); args = "-B"; args += this->ConvertToRelativeOutputPath(m_Makefile->GetHomeOutputDirectory()); - argv.push_back(args); + commandLine.push_back(args); std::string configFile = m_Makefile->GetRequiredDefinition("CMAKE_ROOT"); @@ -177,9 +173,12 @@ void cmLocalVisualStudio7Generator::AddVCProjBuildRule() { listFiles.push_back(configFile); } - m_Makefile->AddCustomCommandToOutput(dspname.c_str(), dsprule.c_str(), - argv, makefileIn.c_str(), listFiles, - NULL, true); + + cmCustomCommandLines commandLines; + commandLines.push_back(commandLine); + const char* no_comment = 0; + m_Makefile->AddCustomCommandToOutput(dspname.c_str(), listFiles, makefileIn.c_str(), + commandLines, no_comment, true); } @@ -1031,18 +1030,14 @@ void cmLocalVisualStudio7Generator::WriteVCProjFile(std::ostream& fout, fout << "\t\t\t\tRelativePath=\"" << d << "\">\n"; if (command) { - std::string totalCommandStr; - totalCommandStr = - this->ConvertToRelativeOutputPath(command->GetCommand().c_str()); - totalCommandStr += " "; - totalCommandStr += command->GetArguments(); - totalCommandStr += "\n"; - const char* comment = command->GetComment().c_str(); + // Construct the entire set of commands in one string. + std::string script = this->ConstructScript(command->GetCommandLines()); + const char* comment = command->GetComment(); const char* flags = compileFlags.size() ? compileFlags.c_str(): 0; - this->WriteCustomRule(fout, source.c_str(), totalCommandStr.c_str(), + this->WriteCustomRule(fout, source.c_str(), script.c_str(), (*comment?comment:"Custom Rule"), command->GetDepends(), - command->GetOutput().c_str(), flags); + command->GetOutput(), flags); } else if(compileFlags.size() || additionalDeps.length()) { @@ -1210,17 +1205,13 @@ void cmLocalVisualStudio7Generator::OutputTargetRules(std::ostream& fout, target.GetPreBuildCommands().begin(); cr != target.GetPreBuildCommands().end(); ++cr) { - 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"; + std::string script = this->ConstructScript(cr->GetCommandLines()); + fout << this->EscapeForXML(script.c_str()).c_str(); } if (init) { @@ -1235,17 +1226,13 @@ void cmLocalVisualStudio7Generator::OutputTargetRules(std::ostream& fout, target.GetPreLinkCommands().begin(); cr != target.GetPreLinkCommands().end(); ++cr) { - 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"; + std::string script = this->ConstructScript(cr->GetCommandLines()); + fout << this->EscapeForXML(script.c_str()).c_str(); } if (init) { @@ -1260,17 +1247,13 @@ void cmLocalVisualStudio7Generator::OutputTargetRules(std::ostream& fout, target.GetPostBuildCommands().begin(); cr != target.GetPostBuildCommands().end(); ++cr) { - 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"; + std::string script = this->ConstructScript(cr->GetCommandLines()); + fout << this->EscapeForXML(script.c_str()).c_str(); } if (init) { @@ -1364,7 +1347,8 @@ void cmLocalVisualStudio7Generator::ConfigureFinalPass() if (strncmp(l->first.c_str(), "INCLUDE_EXTERNAL_MSPROJECT", 26) == 0) { cmCustomCommand cc = l->second.GetPostBuildCommands()[0]; - std::string project_name = cc.GetCommand(); + const cmCustomCommandLines& cmds = cc.GetCommandLines(); + std::string project_name = cmds[0][0]; gg->CreateGUID(project_name.c_str()); } else diff --git a/Source/cmMakefile.cxx b/Source/cmMakefile.cxx index 62a1e7c..25671c9 100644 --- a/Source/cmMakefile.cxx +++ b/Source/cmMakefile.cxx @@ -496,278 +496,253 @@ void cmMakefile::ConfigureFinalPass() } } +//---------------------------------------------------------------------------- +void +cmMakefile::AddCustomCommandToTarget(const char* target, + const std::vector<std::string>& depends, + const cmCustomCommandLines& commandLines, + cmTarget::CustomCommandType type, + const char* comment) +{ + // Find the target to which to add the custom command. + cmTargets::iterator ti = m_Targets.find(target); + if(ti != m_Targets.end()) + { + // Add the command to the appropriate build step for the target. + const char* no_output = 0; + cmCustomCommand cc(no_output, depends, commandLines, comment); + switch(type) + { + case cmTarget::PRE_BUILD: + ti->second.GetPreBuildCommands().push_back(cc); + break; + case cmTarget::PRE_LINK: + ti->second.GetPreLinkCommands().push_back(cc); + break; + case cmTarget::POST_BUILD: + ti->second.GetPostBuildCommands().push_back(cc); + break; + } -// 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, - const std::vector<std::string>& depends, - const std::vector<std::string>& outputs, - 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) - { - // if this looks like a real file then use is as the main depend - cmsys::RegularExpression SourceFiles("\\.(C|M|c|c\\+\\+|cc|cpp|cxx|m|mm|rc|def|r|odl|idl|hpj|bat|h|h\\+\\+|hm|hpp|hxx|in|txx|inl)$"); - if (SourceFiles.find(source)) - { - this->AddCustomCommandToOutput(d->c_str(), command, commandArgs, - source, depends, comment); - } - // otherwise do not use a main depend - else - { - std::vector<std::string> depends2 = depends; - depends2.push_back(source); - this->AddCustomCommandToOutput(d->c_str(), command, commandArgs, - 0, depends2, comment); - } - - // add the output to the target? - std::string sname = *d; - sname += ".rule"; - this->ExpandVariablesInString(sname); - // if the rule was added to the source, - // then add the source to the target - if (!this->GetSource(sname.c_str())) + // Add dependencies on commands CMake knows how to build. + for(cmCustomCommandLines::const_iterator cli = commandLines.begin(); + cli != commandLines.end(); ++cli) + { + std::string cacheCommand = *cli->begin(); + if(const char* knownTarget = + this->GetCacheManager()->GetCacheValue(cacheCommand.c_str())) { - if (m_Targets.find(target) != m_Targets.end()) - { - m_Targets[target].GetSourceLists().push_back(source); - } - else - { - cmSystemTools::Error("Attempt to add a custom rule to a target that does not exist yet for target ", target); - return; - } + ti->second.AddUtility(knownTarget); } } } - else - { - this->AddCustomCommandToTarget(target, command, commandArgs, - cmTarget::POST_BUILD, comment, depends); - } } -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) +//---------------------------------------------------------------------------- +void +cmMakefile::AddCustomCommandToOutput(const char* output, + const std::vector<std::string>& depends, + const char* main_dependency, + const cmCustomCommandLines& commandLines, + const char* comment, + bool replace) { - std::vector<std::string> outputs; - outputs.push_back(output); - this->AddCustomCommand(source, command, commandArgs, depends, - outputs, target); -} - -void cmMakefile:: -AddCustomCommandToOutput(const char* outputIn, - const char* inCommand, - const std::vector<std::string>& commandArgs, - const char *main_dependency, - const std::vector<std::string>& depends, - const char *comment, - bool replace) -{ - std::string expandC; - std::string combinedArgs; - std::string command = inCommand; - - // process the command's string - this->ExpandVariablesInString(command); - command = cmSystemTools::EscapeSpaces(command.c_str()); - - unsigned int i; - bool escapeSpaces = true; - for (i = 0; i < commandArgs.size(); ++i) + // Choose a source file on which to store the custom command. + cmSourceFile* file = 0; + if(main_dependency && main_dependency[0]) { - expandC = commandArgs[i].c_str(); - // This is a hack to fix a problem with cmCustomCommand - // The cmCustomCommand should store the arguments as a vector - // and not a string, and the cmAddCustomTargetCommand should - // not EscapeSpaces. - if(expandC == "This is really a single argument do not escape spaces") - { - escapeSpaces = false; - } - else + // The main dependency was specified. Use it unless a different + // custom command already used it. + file = this->GetSource(main_dependency); + if(file && file->GetCustomCommand() && !replace) { - this->ExpandVariablesInString(expandC); - if(escapeSpaces) + // The main dependency already has a custom command. + if(commandLines == file->GetCustomCommand()->GetCommandLines()) { - combinedArgs += cmSystemTools::EscapeSpaces(expandC.c_str()); + // The existing custom command is identical. Silently ignore + // the duplicate. + return; } else { - combinedArgs += expandC; + // The existing custom command is different. We need to + // generate a rule file for this new command. + file = 0; } - combinedArgs += " "; - } - } - cmSourceFile *file = 0; - - // setup the output name and make sure we expand any variables - std::string output = outputIn; - this->ExpandVariablesInString(output); - std::string outName = output; - outName += ".rule"; - - // setup the main dependency name and expand vars of course - std::string mainDepend; - if (main_dependency && main_dependency[0] != '\0') - { - mainDepend = main_dependency; - this->ExpandVariablesInString(mainDepend); - } - - // 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(mainDepend.c_str()); - if (file && file->GetCustomCommand() && !replace) - { - cmCustomCommand* cc = file->GetCustomCommand(); - // if the command and args are the same - // as the command already there, then silently skip - // this add command - if(cc->IsEquivalent(command.c_str(), combinedArgs.c_str())) - { - return; - } - // generate a source instead - file = 0; } else { - file = this->GetOrCreateSource(mainDepend.c_str()); + // The main dependency does not have a custom command or we are + // allowed to replace it. Use it to store the command. + file = this->GetOrCreateSource(main_dependency); } } - if (!file) + // Generate a rule file if the main dependency is not available. + if(!file) { + // Construct a rule file associated with the output produced. + std::string outName = output; + outName += ".rule"; + + // Check if the rule file already exists. file = this->GetSource(outName.c_str()); - if (file && file->GetCustomCommand() && !replace) + if(file && file->GetCustomCommand() && !replace) { - cmCustomCommand* cc = file->GetCustomCommand(); - // if the command and args are the same - // as the command already there, then silently skip - // this add command - if(cc->IsEquivalent(command.c_str(), combinedArgs.c_str())) + // The rule file already exists. + if(commandLines != file->GetCustomCommand()->GetCommandLines()) { - return; + cmSystemTools::Error("Attempt to add a custom rule to output \"", + output, "\" which already has a custom rule."); } - // produce error if two different commands are given to produce - // the same output - cmSystemTools::Error("Attempt to add a custom rule to an output that already" - " has a custom rule. For output: ", outputIn); return; } - // create a cmSourceFile for the output + + // Create a cmSourceFile for the rule file. file = this->GetOrCreateSource(outName.c_str(), true); - if(file) - { - // always mark as generated - file->SetProperty("GENERATED","1"); - } } - - // always create the output and mark it generated - if(cmSourceFile *out = this->GetOrCreateSource(output.c_str(), true)) + + // Always create the output and mark it generated. + if(cmSourceFile* out = this->GetOrCreateSource(output, true)) { - out->SetProperty("GENERATED","1"); + out->SetProperty("GENERATED", "1"); } - + + // Construct a complete list of dependencies. std::vector<std::string> depends2(depends); - if (main_dependency && main_dependency[0] != '\0') + if(main_dependency && main_dependency[0]) { - depends2.push_back(mainDepend.c_str()); - } - cmCustomCommand *cc = - new cmCustomCommand(command.c_str(),combinedArgs.c_str(),depends2, - output.c_str()); - if ( comment && comment[0] ) - { - cc->SetComment(comment); + depends2.push_back(main_dependency); } + + // Attach the custom command to the file. if(file) { + cmCustomCommand* cc = + new cmCustomCommand(output, depends2, commandLines, comment); file->SetCustomCommand(cc); } } -void cmMakefile:: -AddCustomCommandToTarget(const char* target, const char* command, - const std::vector<std::string>& commandArgs, - cmTarget::CustomCommandType type, - const char *comment) +//---------------------------------------------------------------------------- +void +cmMakefile::AddCustomCommandOldStyle(const char* target, + const std::vector<std::string>& outputs, + const std::vector<std::string>& depends, + const char* source, + const cmCustomCommandLines& commandLines, + const char* comment) { - std::vector<std::string> empty; - this->AddCustomCommandToTarget(target,command,commandArgs,type, - comment, empty); -} + // Translate the old-style signature to one of the new-style + // signatures. + if(strcmp(source, target) == 0) + { + // In the old-style signature if the source and target were the + // same then it added a post-build rule to the target. Preserve + // this behavior. + this->AddCustomCommandToTarget(target, depends, commandLines, + cmTarget::POST_BUILD, comment); + return; + } -void cmMakefile:: -AddCustomCommandToTarget(const char* target, const char* command, - const std::vector<std::string>& commandArgs, - cmTarget::CustomCommandType type, - const char *comment, - const std::vector<std::string>& depends) -{ - // find the target, - if (m_Targets.find(target) != m_Targets.end()) + // Each output must get its own copy of this rule. + cmsys::RegularExpression sourceFiles("\\.(C|M|c|c\\+\\+|cc|cpp|cxx|m|mm|" + "rc|def|r|odl|idl|hpj|bat|h|h\\+\\+|" + "hm|hpp|hxx|in|txx|inl)$"); + for(std::vector<std::string>::const_iterator oi = outputs.begin(); + oi != outputs.end(); ++oi) { - 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) + // Get the name of this output. + const char* output = oi->c_str(); + + // Choose whether to use a main dependency. + if(sourceFiles.find(source)) { - expandC = commandArgs[i].c_str(); - this->ExpandVariablesInString(expandC); - combinedArgs += cmSystemTools::EscapeSpaces(expandC.c_str()); - combinedArgs += " "; + // The source looks like a real file. Use it as the main dependency. + this->AddCustomCommandToOutput(output, depends, source, + commandLines, comment); } - - cmCustomCommand cc(c.c_str(),combinedArgs.c_str(),depends,0); - if ( comment && comment[0] ) + else { - cc.SetComment(comment); + // The source may not be a real file. Do not use a main dependency. + const char* no_main_dependency = 0; + std::vector<std::string> depends2 = depends; + depends2.push_back(source); + this->AddCustomCommandToOutput(output, depends2, no_main_dependency, + commandLines, comment); } - 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())) + + // If the rule was added to the source (and not a .rule file), + // then add the source to the target to make sure the rule is + // included. + std::string sname = output; + sname += ".rule"; + if(!this->GetSource(sname.c_str())) { - m_Targets[target].AddUtility( - this->GetCacheManager()->GetCacheValue(cacheCommand.c_str())); + if (m_Targets.find(target) != m_Targets.end()) + { + m_Targets[target].GetSourceLists().push_back(source); + } + else + { + cmSystemTools::Error("Attempt to add a custom rule to a target " + "that does not exist yet for target ", target); + return; + } } } } +//---------------------------------------------------------------------------- +void cmMakefile::AddUtilityCommand(const char* utilityName, bool all, + const char* output, + const std::vector<std::string>& depends, + const char* command, + const char* arg1, + const char* arg2, + const char* arg3) +{ + // Construct the command line for the custom command. + cmCustomCommandLine commandLine; + commandLine.push_back(command); + if(arg1) + { + commandLine.push_back(arg1); + } + if(arg2) + { + commandLine.push_back(arg2); + } + if(arg3) + { + commandLine.push_back(arg3); + } + cmCustomCommandLines commandLines; + commandLines.push_back(commandLine); + + // Call the real signature of this method. + this->AddUtilityCommand(utilityName, all, output, depends, commandLines); +} + +//---------------------------------------------------------------------------- +void cmMakefile::AddUtilityCommand(const char* utilityName, bool all, + const char* output, + const std::vector<std::string>& depends, + const cmCustomCommandLines& commandLines) +{ + // Create a target instance for this utility. + cmTarget target; + target.SetType(cmTarget::UTILITY, utilityName); + target.SetInAll(all); + + // Store the custom command in the target. + cmCustomCommand cc(output, depends, commandLines, 0); + target.GetPostBuildCommands().push_back(cc); + + // Add the target to the set of targets. + m_Targets.insert(cmTargets::value_type(utilityName, target)); +} + void cmMakefile::AddDefineFlag(const char* flag) { m_DefineFlags += " "; @@ -1128,48 +1103,6 @@ cmTarget* cmMakefile::AddExecutable(const char *exeName, return &it->second; } - -void cmMakefile::AddUtilityCommand(const char* utilityName, - const char* command, - const char* arguments, - bool all, - const std::vector<std::string> &depends) -{ - std::vector<std::string> empty; - this->AddUtilityCommand(utilityName,command,arguments,all, - depends, empty); -} - -void cmMakefile::AddUtilityCommand(const char* utilityName, - const char* command, - const char* arguments, - bool all, - const std::vector<std::string> &dep, - const std::vector<std::string> &out) -{ - cmTarget target; - target.SetType(cmTarget::UTILITY, utilityName); - target.SetInAll(all); - 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, (const char *)0); - target.GetPostBuildCommands().push_back(cc); - } - m_Targets.insert(cmTargets::value_type(utilityName,target)); -} - cmSourceFile *cmMakefile::GetSourceFileWithOutput(const char *cname) { std::string name = cname; @@ -1323,42 +1256,6 @@ void cmMakefile::ExpandVariables() } } -void cmMakefile::ExpandVariablesInCustomCommands() -{ - // do source files - for(std::vector<cmSourceFile*>::iterator i = m_SourceFiles.begin(); - i != m_SourceFiles.end(); ++i) - { - cmCustomCommand *cc = (*i)->GetCustomCommand(); - if (cc) - { - cc->ExpandVariables(*this); - } - } - - // now do targets - std::vector<cmCustomCommand>::iterator ic; - for (cmTargets::iterator l = m_Targets.begin(); - l != m_Targets.end(); l++) - { - for (ic = l->second.GetPreBuildCommands().begin(); - ic != l->second.GetPreBuildCommands().end(); ++ic) - { - ic->ExpandVariables(*this); - } - for (ic = l->second.GetPreLinkCommands().begin(); - ic != l->second.GetPreLinkCommands().end(); ++ic) - { - ic->ExpandVariables(*this); - } - for (ic = l->second.GetPostBuildCommands().begin(); - ic != l->second.GetPostBuildCommands().end(); ++ic) - { - ic->ExpandVariables(*this); - } - } -} - bool cmMakefile::IsOn(const char* name) const { const char* value = this->GetDefinition(name); diff --git a/Source/cmMakefile.h b/Source/cmMakefile.h index 4f99b5c..dd3c88b 100644 --- a/Source/cmMakefile.h +++ b/Source/cmMakefile.h @@ -130,47 +130,26 @@ public: * Print the object state to std::cout. */ void Print() const; - - /** - * Add a custom command to the build. - */ + + /** Add a custom command to the build. */ + void AddCustomCommandToTarget(const char* target, + const std::vector<std::string>& depends, + const cmCustomCommandLines& commandLines, + cmTarget::CustomCommandType type, + const char* comment); 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, + const char* main_dependency, + const cmCustomCommandLines& commandLines, + const char* comment, bool replace = false); - void AddCustomCommandToTarget(const char* target, - const char* command, - const std::vector<std::string>& commandArgs, - cmTarget::CustomCommandType type, - const char *comment = 0); - void AddCustomCommandToTarget(const char* target, - const char* command, - const std::vector<std::string>& commandArgs, - cmTarget::CustomCommandType type, - const char *comment, - const std::vector<std::string>& depends); - - /** - * Add a custom command to the build. - */ - void AddCustomCommand(const char* source, - const char* command, - const std::vector<std::string>& commandArgs, - const std::vector<std::string>& depends, - const std::vector<std::string>& outputs, - const char *target, - const char *comment = 0); - - void 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); - + void AddCustomCommandOldStyle(const char* target, + const std::vector<std::string>& outputs, + const std::vector<std::string>& depends, + const char* source, + const cmCustomCommandLines& commandLines, + const char* comment); + /** * Add a define flag to the build. */ @@ -184,20 +163,20 @@ public: const std::vector<std::string> &srcs); /** - * Add a utility to the build. A utiltity target is - * a command that is run every time a target is built. + * Add a utility to the build. A utiltity target is a command that + * is run every time the target is built. */ - void AddUtilityCommand(const char* utilityName, - const char* command, - const char* arguments, - bool all, - const std::vector<std::string> &depends); - void AddUtilityCommand(const char* utilityName, + void AddUtilityCommand(const char* utilityName, bool all, + const char* output, + const std::vector<std::string>& depends, const char* command, - const char* arguments, - bool all, - const std::vector<std::string> &depends, - const std::vector<std::string> &outputs); + const char* arg1=0, + const char* arg2=0, + const char* arg3=0); + void AddUtilityCommand(const char* utilityName, bool all, + const char* output, + const std::vector<std::string>& depends, + const cmCustomCommandLines& commandLines); /** * Add a link library to the build. @@ -577,7 +556,6 @@ public: * Expand variables in the makefiles ivars such as link directories etc */ void ExpandVariables(); - void ExpandVariablesInCustomCommands(); /** * Replace variables and #cmakedefine lines in the given string. diff --git a/Source/cmQTWrapCPPCommand.cxx b/Source/cmQTWrapCPPCommand.cxx index 9f74a71..edf215a 100644 --- a/Source/cmQTWrapCPPCommand.cxx +++ b/Source/cmQTWrapCPPCommand.cxx @@ -99,19 +99,11 @@ void cmQTWrapCPPCommand::FinalPass() // first we add the rules for all the .h to Moc files size_t lastClass = m_WrapClasses.size(); std::vector<std::string> depends; - std::string moc_exe = "${QT_MOC_EXECUTABLE}"; + const char* moc_exe = m_Makefile->GetRequiredDefinition("QT_MOC_EXECUTABLE"); // wrap all the .h files depends.push_back(moc_exe); - const char * GENERATED_QT_FILES_value= - m_Makefile->GetDefinition("GENERATED_QT_FILES"); - std::string moc_list(""); - if (GENERATED_QT_FILES_value!=0) - { - moc_list=moc_list+GENERATED_QT_FILES_value; - } - for(size_t classNum = 0; classNum < lastClass; classNum++) { // Add output to build list @@ -122,28 +114,23 @@ void cmQTWrapCPPCommand::FinalPass() res += "/"; res += m_WrapClasses[classNum].GetSourceName() + ".cxx"; - moc_list = moc_list + " " + res; - - std::vector<std::string> args; - args.push_back("-o"); - args.push_back(res); - args.push_back(m_WrapHeaders[classNum]); + cmCustomCommandLine commandLine; + commandLine.push_back(moc_exe); + commandLine.push_back("-o"); + commandLine.push_back(res); + commandLine.push_back(m_WrapHeaders[classNum]); + + cmCustomCommandLines commandLines; + commandLines.push_back(commandLine); std::vector<std::string> realdepends = depends; realdepends.push_back(m_WrapHeaders[classNum]); - m_Makefile->AddCustomCommandToOutput( - res.c_str(), - moc_exe.c_str(), - args, - 0, - realdepends, - "QT Wrapped File", - 0); + const char* no_main_dependency = 0; + m_Makefile->AddCustomCommandToOutput(res.c_str(), + realdepends, + no_main_dependency, + commandLines, + "QT Wrapped File"); } - - m_Makefile->AddDefinition("GENERATED_QT_FILES",moc_list.c_str()); } - - - diff --git a/Source/cmQTWrapUICommand.cxx b/Source/cmQTWrapUICommand.cxx index b742322..e4b864b 100644 --- a/Source/cmQTWrapUICommand.cxx +++ b/Source/cmQTWrapUICommand.cxx @@ -125,25 +125,15 @@ void cmQTWrapUICommand::FinalPass() // first we add the rules for all the .ui to .h and .cxx files size_t lastHeadersClass = m_WrapHeadersClasses.size(); std::vector<std::string> depends; - std::string uic_exe = "${QT_UIC_EXECUTABLE}"; - std::string moc_exe = "${QT_MOC_EXECUTABLE}"; - + const char* uic_exe = m_Makefile->GetRequiredDefinition("QT_UIC_EXECUTABLE"); + const char* moc_exe = m_Makefile->GetRequiredDefinition("QT_MOC_EXECUTABLE"); // wrap all the .h files depends.push_back(uic_exe); - const char * GENERATED_QT_FILES_value= - m_Makefile->GetDefinition("GENERATED_QT_FILES"); - std::string ui_list(""); - if (GENERATED_QT_FILES_value!=0) - { - ui_list=ui_list+GENERATED_QT_FILES_value; - } - for(size_t classNum = 0; classNum < lastHeadersClass; classNum++) { // set up .ui to .h and .cxx command - std::string hres = m_Makefile->GetCurrentOutputDirectory(); hres += "/"; hres += m_WrapHeadersClasses[classNum].GetSourceName() + "." + @@ -159,52 +149,58 @@ void cmQTWrapUICommand::FinalPass() mocres += m_WrapMocClasses[classNum].GetSourceName() + "." + m_WrapMocClasses[classNum].GetSourceExtension(); - ui_list = ui_list + " " + hres + " " + cxxres + " " + mocres; - - std::vector<std::string> hargs; - hargs.push_back("-o"); - hargs.push_back(hres); - hargs.push_back(m_WrapUserInterface[classNum]); - - std::vector<std::string> cxxargs; - cxxargs.push_back("-impl"); - cxxargs.push_back(hres); - cxxargs.push_back("-o"); - cxxargs.push_back(cxxres); - cxxargs.push_back(m_WrapUserInterface[classNum]); + cmCustomCommandLine hCommand; + hCommand.push_back(uic_exe); + hCommand.push_back("-o"); + hCommand.push_back(hres); + hCommand.push_back(m_WrapUserInterface[classNum]); + cmCustomCommandLines hCommandLines; + hCommandLines.push_back(hCommand); + + cmCustomCommandLine cxxCommand; + cxxCommand.push_back(uic_exe); + cxxCommand.push_back("-impl"); + cxxCommand.push_back(hres); + cxxCommand.push_back("-o"); + cxxCommand.push_back(cxxres); + cxxCommand.push_back(m_WrapUserInterface[classNum]); + cmCustomCommandLines cxxCommandLines; + cxxCommandLines.push_back(cxxCommand); std::vector<std::string> mocargs; - mocargs.push_back("-o"); - mocargs.push_back(mocres); - mocargs.push_back(hres); + cmCustomCommandLine mocCommand; + mocCommand.push_back(moc_exe); + mocCommand.push_back("-o"); + mocCommand.push_back(mocres); + mocCommand.push_back(hres); + cmCustomCommandLines mocCommandLines; + mocCommandLines.push_back(mocCommand); depends.clear(); depends.push_back(m_WrapUserInterface[classNum]); - m_Makefile->AddCustomCommandToOutput( - hres.c_str(), - uic_exe.c_str(), hargs, 0, - depends); + const char* no_main_dependency = 0; + const char* no_comment = 0; + m_Makefile->AddCustomCommandToOutput(hres.c_str(), + depends, + no_main_dependency, + hCommandLines, + no_comment); depends.push_back(hres); - m_Makefile->AddCustomCommandToOutput( - cxxres.c_str(), - uic_exe.c_str(), cxxargs, 0, depends); - - + m_Makefile->AddCustomCommandToOutput(cxxres.c_str(), + depends, + no_main_dependency, + cxxCommandLines, + no_comment); depends.clear(); depends.push_back(hres); - m_Makefile->AddCustomCommandToOutput( - mocres.c_str(), - moc_exe.c_str(), mocargs, 0, depends); - + m_Makefile->AddCustomCommandToOutput(mocres.c_str(), + depends, + no_main_dependency, + mocCommandLines, + no_comment); } - - m_Makefile->AddDefinition("GENERATED_QT_FILES",ui_list.c_str()); - } - - - diff --git a/Source/cmVTKWrapJavaCommand.cxx b/Source/cmVTKWrapJavaCommand.cxx index c6f8c35..67e6bba 100644 --- a/Source/cmVTKWrapJavaCommand.cxx +++ b/Source/cmVTKWrapJavaCommand.cxx @@ -49,7 +49,7 @@ bool cmVTKWrapJavaCommand::InitialPass(std::vector<std::string> const& argsIn) } // Prepare java dependency file - std::string resultDirectory = "${VTK_JAVA_HOME}"; + const char* resultDirectory = m_Makefile->GetRequiredDefinition("VTK_JAVA_HOME"); std::string res = m_Makefile->GetCurrentOutputDirectory(); std::string depFileName = res + "/JavaDependencies.cmake"; std::ofstream depFile(depFileName.c_str()); @@ -88,7 +88,10 @@ bool cmVTKWrapJavaCommand::InitialPass(std::vector<std::string> const& argsIn) sourceListValue += newName + ".cxx"; // Write file to java dependency file - std::string jafaFile = resultDirectory + "/" + srcName + ".java"; + std::string jafaFile = resultDirectory; + jafaFile += "/"; + jafaFile += srcName; + jafaFile += ".java"; depFile << " " << jafaFile << std::endl; } } @@ -107,18 +110,15 @@ void cmVTKWrapJavaCommand::FinalPass() std::vector<std::string> depends; std::vector<std::string> depends2; std::vector<std::string> alldepends; - std::vector<std::string> empty; - std::string wjava = "${VTK_WRAP_JAVA_EXE}"; - std::string pjava = "${VTK_PARSE_JAVA_EXE}"; - std::string hints = "${VTK_WRAP_HINTS}"; - std::string resultDirectory = "${VTK_JAVA_HOME}"; - - m_Makefile->ExpandVariablesInString(hints); + const char* wjava = m_Makefile->GetRequiredDefinition("VTK_WRAP_JAVA_EXE"); + const char* pjava = m_Makefile->GetRequiredDefinition("VTK_PARSE_JAVA_EXE"); + const char* hints = m_Makefile->GetDefinition("VTK_WRAP_HINTS"); + const char* resultDirectory = m_Makefile->GetRequiredDefinition("VTK_JAVA_HOME"); // wrap all the .h files depends.push_back(wjava); depends2.push_back(pjava); - if (strcmp("${VTK_WRAP_HINTS}",hints.c_str())) + if(hints) { depends.push_back(hints); depends2.push_back(hints); @@ -131,45 +131,57 @@ void cmVTKWrapJavaCommand::FinalPass() std::string res = m_Makefile->GetCurrentOutputDirectory(); res += "/"; res += m_WrapClasses[classNum].GetSourceName() + ".cxx"; - std::string res2 = resultDirectory + "/" + - m_OriginalNames[classNum] + ".java"; + std::string res2 = resultDirectory; + res2 += "/"; + res2 += m_OriginalNames[classNum]; + res2 += ".java"; - std::vector<std::string> args; - args.push_back(m_WrapHeaders[classNum]); - if (strcmp("${VTK_WRAP_HINTS}",hints.c_str())) + cmCustomCommandLine commandLineW; + commandLineW.push_back(wjava); + commandLineW.push_back(m_WrapHeaders[classNum]); + if(hints) { - args.push_back(hints); + commandLineW.push_back(hints); } - args.push_back((m_WrapClasses[classNum].GetPropertyAsBool("ABSTRACT") ? "0" : "1")); - args.push_back(res); - - m_Makefile->AddCustomCommand(m_WrapHeaders[classNum].c_str(), - wjava.c_str(), args, depends, - res.c_str(), m_LibraryName.c_str()); - - std::vector<std::string> args2; - args2.push_back(m_WrapHeaders[classNum]); - if (strcmp("${VTK_WRAP_HINTS}",hints.c_str())) + commandLineW.push_back((m_WrapClasses[classNum].GetPropertyAsBool("ABSTRACT") ? "0" : "1")); + commandLineW.push_back(res); + + cmCustomCommandLines commandLines; + commandLines.push_back(commandLineW); + std::vector<std::string> outputs; + outputs.push_back(res); + const char* no_comment = 0; + m_Makefile->AddCustomCommandOldStyle(m_LibraryName.c_str(), + outputs, + depends, + m_WrapHeaders[classNum].c_str(), + commandLines, + no_comment); + + cmCustomCommandLine commandLineP; + commandLineP.push_back(pjava); + commandLineP.push_back(m_WrapHeaders[classNum]); + if(hints) { - args2.push_back(hints); + commandLineP.push_back(hints); } - args2.push_back((m_WrapClasses[classNum].GetPropertyAsBool("ABSTRACT") ? "0" : "1")); - args2.push_back(res2); - - m_Makefile->AddCustomCommand(m_WrapHeaders[classNum].c_str(), - pjava.c_str(), args2, depends2, - res2.c_str(), m_LibraryName.c_str()); + commandLineP.push_back((m_WrapClasses[classNum].GetPropertyAsBool("ABSTRACT") ? "0" : "1")); + commandLineP.push_back(res2); + + cmCustomCommandLines commandLines2; + commandLines2.push_back(commandLineP); + std::vector<std::string> outputs2; + outputs2.push_back(res2); + m_Makefile->AddCustomCommandOldStyle(m_LibraryName.c_str(), + outputs2, + depends2, + m_WrapHeaders[classNum].c_str(), + commandLines2, + no_comment); alldepends.push_back(res2); } + const char* no_output = 0; m_Makefile->AddUtilityCommand((m_LibraryName+"JavaClasses").c_str(), - "", - "", - true, - alldepends, - empty); - + true, no_output, alldepends, ""); } - - - diff --git a/Source/cmVTKWrapPythonCommand.cxx b/Source/cmVTKWrapPythonCommand.cxx index 3bde306..b9aa32d 100644 --- a/Source/cmVTKWrapPythonCommand.cxx +++ b/Source/cmVTKWrapPythonCommand.cxx @@ -102,14 +102,12 @@ void cmVTKWrapPythonCommand::FinalPass() // first we add the rules for all the .h to Python.cxx files size_t lastClass = m_WrapClasses.size(); std::vector<std::string> depends; - std::string wpython = "${VTK_WRAP_PYTHON_EXE}"; - std::string hints = "${VTK_WRAP_HINTS}"; - - m_Makefile->ExpandVariablesInString(hints); + const char* wpython = m_Makefile->GetRequiredDefinition("VTK_WRAP_PYTHON_EXE"); + const char* hints = m_Makefile->GetDefinition("VTK_WRAP_HINTS"); // wrap all the .h files depends.push_back(wpython); - if (strcmp("${VTK_WRAP_HINTS}",hints.c_str())) + if(hints) { depends.push_back(hints); } @@ -119,18 +117,27 @@ void cmVTKWrapPythonCommand::FinalPass() std::string res = m_Makefile->GetCurrentOutputDirectory(); res += "/"; res += m_WrapClasses[classNum].GetSourceName() + ".cxx"; - std::vector<std::string> args; - args.push_back(m_WrapHeaders[classNum]); - if (strcmp("${VTK_WRAP_HINTS}",hints.c_str())) + cmCustomCommandLine commandLine; + commandLine.push_back(wpython); + commandLine.push_back(m_WrapHeaders[classNum]); + if(hints) { - args.push_back(hints); + commandLine.push_back(hints); } - args.push_back((m_WrapClasses[classNum].GetPropertyAsBool("ABSTRACT") ? "0" : "1")); - args.push_back(res); - - m_Makefile->AddCustomCommand(m_WrapHeaders[classNum].c_str(), - wpython.c_str(), args, depends, - res.c_str(), m_LibraryName.c_str()); + commandLine.push_back((m_WrapClasses[classNum].GetPropertyAsBool("ABSTRACT") ? "0" : "1")); + commandLine.push_back(res); + + cmCustomCommandLines commandLines; + commandLines.push_back(commandLine); + std::vector<std::string> outputs; + outputs.push_back(res); + const char* no_comment = 0; + m_Makefile->AddCustomCommandOldStyle(m_LibraryName.c_str(), + outputs, + depends, + m_WrapHeaders[classNum].c_str(), + commandLines, + no_comment); } } diff --git a/Source/cmVTKWrapTclCommand.cxx b/Source/cmVTKWrapTclCommand.cxx index b1e4d1a..2daad71 100644 --- a/Source/cmVTKWrapTclCommand.cxx +++ b/Source/cmVTKWrapTclCommand.cxx @@ -144,35 +144,42 @@ void cmVTKWrapTclCommand::FinalPass() // first we add the rules for all the .h to Tcl.cxx files size_t lastClass = m_WrapClasses.size(); std::vector<std::string> depends; - std::string wtcl = "${VTK_WRAP_TCL_EXE}"; - std::string hints = "${VTK_WRAP_HINTS}"; - - m_Makefile->ExpandVariablesInString(hints); + const char* wtcl = m_Makefile->GetRequiredDefinition("VTK_WRAP_TCL_EXE"); + const char* hints = m_Makefile->GetDefinition("VTK_WRAP_HINTS"); // wrap all the .h files depends.push_back(wtcl); - if (strcmp("${VTK_WRAP_HINTS}",hints.c_str())) + if(hints) { depends.push_back(hints); } for(size_t classNum = 0; classNum < lastClass; classNum++) { m_Makefile->AddSource(m_WrapClasses[classNum]); - std::vector<std::string> args; - args.push_back(m_WrapHeaders[classNum]); - if (strcmp("${VTK_WRAP_HINTS}",hints.c_str())) + cmCustomCommandLine commandLine; + commandLine.push_back(wtcl); + commandLine.push_back(m_WrapHeaders[classNum]); + if(hints) { - args.push_back(hints); + commandLine.push_back(hints); } - args.push_back((m_WrapClasses[classNum].GetPropertyAsBool("ABSTRACT") ? "0" : "1")); + commandLine.push_back((m_WrapClasses[classNum].GetPropertyAsBool("ABSTRACT") ? "0" : "1")); std::string res = m_Makefile->GetCurrentOutputDirectory(); res += "/"; res += m_WrapClasses[classNum].GetSourceName() + ".cxx"; - args.push_back(res); - - m_Makefile->AddCustomCommand(m_WrapHeaders[classNum].c_str(), - wtcl.c_str(), args, depends, - res.c_str(), m_LibraryName.c_str()); + commandLine.push_back(res); + + cmCustomCommandLines commandLines; + commandLines.push_back(commandLine); + std::vector<std::string> outputs; + outputs.push_back(res); + const char* no_comment = 0; + m_Makefile->AddCustomCommandOldStyle(m_LibraryName.c_str(), + outputs, + depends, + m_WrapHeaders[classNum].c_str(), + commandLines, + no_comment); } } |