kolan
/
CMake
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

ENH: Updated implementation of custom commands. Multiple command lines are now supported effectively allowing entire scripts to be written. Also removed extra variable expansions and cleaned up passing of commands through to the generators. The command and individual arguments are now kept separate all the way until the generator writes them out. This cleans up alot of escaping issues.

This commit is contained in:
Brad King 2005-02-22 10:32:44 -05:00
parent 4d30cb309c
commit 39af9ee1e4
27 changed files with 938 additions and 945 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

87
Source/cmAddCustomCommandCommand.cxx
View File

@ -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.
*/
// 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;
}

13
Source/cmAddCustomCommandCommand.h
View File

@ -67,8 +67,8 @@ public:
"The first signature is for adding a custom command "
"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 "

92
Source/cmAddCustomTargetCommand.cxx
View File

@ -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")
{
all = true;
++s; // skip all
start = 2;
}
}
std::string command;
if(s != args.end() && *s != "DEPENDS")
// Parse the rest of the arguments.
for(unsigned int j = start; j < args.size(); ++j)
{
command = *s;
++s;
}
for (;s != args.end() && *s != "DEPENDS"; ++s)
std::string const& copy = args[j];
if(copy == "DEPENDS")
{
arguments += cmSystemTools::EscapeSpaces(s->c_str());
arguments += " ";
doing = doing_depends;
}
std::vector<std::string> depends;
// skip depends keyword
if (s != args.end())
else if(copy == "COMMAND")
{
++s;
}
while (s != args.end())
doing = doing_command;
// Save the current command before starting the next command.
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);
}
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;
}
}
}
// Store the last command line finished.
if(!currentLine.empty())
{
commandLines.push_back(currentLine);
currentLine.clear();
}
// 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;
}

5
Source/cmAddCustomTargetCommand.h
View File

@ -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. "

140
Source/cmCPluginAPI.cxx
View File

@ -203,20 +203,44 @@ void cmAddUtilityCommand(void *arg, const char* utilityName,
int numOutputs,
const char **outputs)
{
// 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)
{
// Get the makefile instance. Perform an extra variable expansion
// now because the API caller expects it.
cmMakefile* mf = static_cast<cmMakefile*>(arg);
int i;
std::vector<std::string> args2;
for (i = 0; i < numArgs; ++i)
// 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)
{
// Get the makefile instance. Perform an extra variable expansion
// now because the API caller expects it.
cmMakefile* mf = static_cast<cmMakefile*>(arg);
int i;
std::vector<std::string> args2;
for (i = 0; i < numArgs; ++i)
// 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)
{
// Get the makefile instance.
cmMakefile* mf = static_cast<cmMakefile*>(arg);
int i;
std::vector<std::string> args2;
for (i = 0; i < numArgs; ++i)
// 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,

79
Source/cmCustomCommand.cxx
View File

@ -15,68 +15,53 @@
=========================================================================*/
#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)
{
if (out)
{
m_Output = out;
}
}
cmCustomCommand::cmCustomCommand(const char *command,
const char* arguments):
m_Command(command),
m_Arguments(arguments)
//----------------------------------------------------------------------------
cmCustomCommand::cmCustomCommand()
{
}
/**
* 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)
m_Depends(r.m_Depends),
m_CommandLines(r.m_CommandLines),
m_Comment(r.m_Comment)
{
}
void cmCustomCommand::ExpandVariables(const cmMakefile &mf)
//----------------------------------------------------------------------------
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:"")
{
mf.ExpandVariablesInString(m_Command);
mf.ExpandVariablesInString(m_Arguments);
mf.ExpandVariablesInString(m_Output);
for (std::vector<std::string>::iterator i = m_Depends.begin();
i != m_Depends.end(); ++i)
{
mf.ExpandVariablesInString(*i);
}
}
//----------------------------------------------------------------------------
const char* cmCustomCommand::GetOutput() const
{
return m_Output.c_str();
}
bool cmCustomCommand::IsEquivalent(const char* command,
const char* args)
//----------------------------------------------------------------------------
const std::vector<std::string>& cmCustomCommand::GetDepends() const
{
if(m_Command != command)
return m_Depends;
}
//----------------------------------------------------------------------------
const cmCustomCommandLines& cmCustomCommand::GetCommandLines() const
{
return false;
return m_CommandLines;
}
if(m_Arguments != args)
//----------------------------------------------------------------------------
const char* cmCustomCommand::GetComment() const
{
return false;
}
return true;
return m_Comment.c_str();
}

59
Source/cmCustomCommand.h
View File

@ -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 &);
/** 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 command to execute with arguments
std::string GetCommandAndArguments() const
{return m_Command + " " + m_Arguments;}
/** Get the output file produced by the command. */
const char* GetOutput() const;
///! Return the command to execute
const std::string &GetCommand() const {return m_Command;}
void SetCommand(const char *cmd) {m_Command = cmd;}
/** Get the vector that holds the list of dependencies. */
const std::vector<std::string>& GetDepends() const;
///! Return the output
const std::string &GetOutput() const {return m_Output;}
void SetOutput(const char *cm) {m_Output = cm;}
/** Get the list of command lines. */
const cmCustomCommandLines& GetCommandLines() const;
///! Return the comment
const std::string &GetComment() const {return m_Comment;}
void SetComment(const char *cm) {m_Comment = cm;}
/** 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

35
Source/cmFLTKWrapUICommand.cxx
View File

@ -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
@ -67,26 +68,26 @@ bool cmFLTKWrapUICommand::InitialPass(std::vector<std::string> const& args)
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);

22
Source/cmGlobalVisualStudio6Generator.cxx
View File

@ -170,7 +170,8 @@ void cmGlobalVisualStudio6Generator::Generate()
{
// add a special target that depends on ALL projects for easy build
// of one configuration only.
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)
{
@ -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)");
}
}
}

13
Source/cmGlobalVisualStudio71Generator.cxx
View File

@ -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)

34
Source/cmGlobalVisualStudio7Generator.cxx
View File

@ -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)

54
Source/cmGlobalXCodeGenerator.cxx
View File

@ -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();

60
Source/cmITKWrapTclCommand.cxx
View File

@ -105,22 +105,23 @@ 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);

6
Source/cmIncludeExternalMSProjectCommand.cxx
View File

@ -43,8 +43,10 @@ bool cmIncludeExternalMSProjectCommand::InitialPass(std::vector<std::string> con
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

35
Source/cmLocalGenerator.cxx
View File

@ -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;
}

3
Source/cmLocalGenerator.h
View File

@ -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,

45
Source/cmLocalUnixMakefileGenerator.cxx
View File

@ -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());
}
}
}

30
Source/cmLocalUnixMakefileGenerator2.cxx
View File

@ -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,17 +2734,23 @@ cmLocalUnixMakefileGenerator2
{
// TODO: Convert outputs/dependencies (arguments?) to relative paths.
// 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.
std::string cmd = cc.GetCommand();
const cmCustomCommandLine& commandLine = *cl;
std::string cmd = commandLine[0];
cmSystemTools::ReplaceString(cmd, "/./", "/");
cmd = this->ConvertToRelativeOutputPath(cmd.c_str());
if(cc.GetArguments().size() > 0)
for(unsigned int j=1; j < commandLine.size(); ++j)
{
cmd += " ";
cmd += cc.GetArguments();
cmd += cmSystemTools::EscapeSpaces(commandLine[j].c_str());
}
commands.push_back(cmd);
}
}
//----------------------------------------------------------------------------
void

71
Source/cmLocalVisualStudio6Generator.cxx
View File

@ -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());
const char* no_main_dependency = 0;
const char* no_comment = 0;
m_Makefile->AddCustomCommandToOutput(output,
cc.GetCommand().c_str(),
args,
0,
cc.GetDepends());
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";

66
Source/cmLocalVisualStudio7Generator.cxx
View File

@ -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, "\"", "&quot;");
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, "\"", "&quot;");
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, "\"", "&quot;");
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

531
Source/cmMakefile.cxx
View File

@ -496,45 +496,187 @@ void cmMakefile::ConfigureFinalPass()
}
}
// this is the old style signature, we convert to new style
void cmMakefile::AddCustomCommand(const char* source,
const char* command,
const std::vector<std::string>& commandArgs,
//----------------------------------------------------------------------------
void
cmMakefile::AddCustomCommandToTarget(const char* target,
const std::vector<std::string>& depends,
const std::vector<std::string>& outputs,
const char *target,
const cmCustomCommandLines& commandLines,
cmTarget::CustomCommandType type,
const char* comment)
{
if (strcmp(source,target))
// Find the target to which to add the custom command.
cmTargets::iterator ti = m_Targets.find(target);
if(ti != m_Targets.end())
{
// 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)
// 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)
{
// 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);
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;
}
// add the output to the target?
std::string sname = *d;
// 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()))
{
ti->second.AddUtility(knownTarget);
}
}
}
}
//----------------------------------------------------------------------------
void
cmMakefile::AddCustomCommandToOutput(const char* output,
const std::vector<std::string>& depends,
const char* main_dependency,
const cmCustomCommandLines& commandLines,
const char* comment,
bool replace)
{
// Choose a source file on which to store the custom command.
cmSourceFile* file = 0;
if(main_dependency && main_dependency[0])
{
// 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)
{
// The main dependency already has a custom command.
if(commandLines == file->GetCustomCommand()->GetCommandLines())
{
// The existing custom command is identical. Silently ignore
// the duplicate.
return;
}
else
{
// The existing custom command is different. We need to
// generate a rule file for this new command.
file = 0;
}
}
else
{
// 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);
}
}
// 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)
{
// The rule file already exists.
if(commandLines != file->GetCustomCommand()->GetCommandLines())
{
cmSystemTools::Error("Attempt to add a custom rule to output \"",
output, "\" which already has a custom rule.");
}
return;
}
// Create a cmSourceFile for the rule file.
file = this->GetOrCreateSource(outName.c_str(), true);
}
// Always create the output and mark it generated.
if(cmSourceFile* out = this->GetOrCreateSource(output, true))
{
out->SetProperty("GENERATED", "1");
}
// Construct a complete list of dependencies.
std::vector<std::string> depends2(depends);
if(main_dependency && main_dependency[0])
{
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::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)
{
// 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;
}
// 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)
{
// Get the name of this output.
const char* output = oi->c_str();
// Choose whether to use a main dependency.
if(sourceFiles.find(source))
{
// The source looks like a real file. Use it as the main dependency.
this->AddCustomCommandToOutput(output, depends, source,
commandLines, comment);
}
else
{
// 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);
}
// 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";
this->ExpandVariablesInString(sname);
// if the rule was added to the source,
// then add the source to the target
if(!this->GetSource(sname.c_str()))
{
if (m_Targets.find(target) != m_Targets.end())
@ -543,229 +685,62 @@ void cmMakefile::AddCustomCommand(const char* source,
}
else
{
cmSystemTools::Error("Attempt to add a custom rule to a target that does not exist yet for target ", target);
cmSystemTools::Error("Attempt to add a custom rule to a target "
"that does not exist yet for target ", target);
return;
}
}
}
}
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,
//----------------------------------------------------------------------------
void cmMakefile::AddUtilityCommand(const char* utilityName, bool all,
const char* output,
const char *target)
{
std::vector<std::string> outputs;
outputs.push_back(output);
this->AddCustomCommand(source, command, commandArgs, depends,
outputs, target);
}
void cmMakefile::
AddCustomCommandToOutput(const char* 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)
const char* command,
const char* arg1,
const char* arg2,
const char* arg3)
{
std::string expandC;
std::string combinedArgs;
std::string command = inCommand;
// 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);
// 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)
{
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
{
this->ExpandVariablesInString(expandC);
if(escapeSpaces)
{
combinedArgs += cmSystemTools::EscapeSpaces(expandC.c_str());
}
else
{
combinedArgs += expandC;
}
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);
// Call the real signature of this method.
this->AddUtilityCommand(utilityName, all, output, depends, commandLines);
}
// OK this rule will be placed on a generated output file unless the main
// depednency was specified.
if (main_dependency && main_dependency[0] != '\0')
//----------------------------------------------------------------------------
void cmMakefile::AddUtilityCommand(const char* utilityName, bool all,
const char* output,
const std::vector<std::string>& depends,
const cmCustomCommandLines& commandLines)
{
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());
}
}
// Create a target instance for this utility.
cmTarget target;
target.SetType(cmTarget::UTILITY, utilityName);
target.SetInAll(all);
if (!file)
{
file = this->GetSource(outName.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;
}
// 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
file = this->GetOrCreateSource(outName.c_str(), true);
if(file)
{
// always mark as generated
file->SetProperty("GENERATED","1");
}
}
// Store the custom command in the target.
cmCustomCommand cc(output, depends, commandLines, 0);
target.GetPostBuildCommands().push_back(cc);
// always create the output and mark it generated
if(cmSourceFile *out = this->GetOrCreateSource(output.c_str(), true))
{
out->SetProperty("GENERATED","1");
}
std::vector<std::string> depends2(depends);
if (main_dependency && main_dependency[0] != '\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);
}
if(file)
{
file->SetCustomCommand(cc);
}
}
void cmMakefile::
AddCustomCommandToTarget(const char* target, const char* command,
const std::vector<std::string>& commandArgs,
cmTarget::CustomCommandType type,
const char *comment)
{
std::vector<std::string> empty;
this->AddCustomCommandToTarget(target,command,commandArgs,type,
comment, empty);
}
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())
{
std::string expandC = command;
this->ExpandVariablesInString(expandC);
std::string c = cmSystemTools::EscapeSpaces(expandC.c_str());
std::string combinedArgs;
unsigned int i;
for (i = 0; i < commandArgs.size(); ++i)
{
expandC = commandArgs[i].c_str();
this->ExpandVariablesInString(expandC);
combinedArgs += cmSystemTools::EscapeSpaces(expandC.c_str());
combinedArgs += " ";
}
cmCustomCommand cc(c.c_str(),combinedArgs.c_str(),depends,0);
if ( comment && comment[0] )
{
cc.SetComment(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()))
{
m_Targets[target].AddUtility(
this->GetCacheManager()->GetCacheValue(cacheCommand.c_str()));
}
}
// Add the target to the set of targets.
m_Targets.insert(cmTargets::value_type(utilityName, target));
}
void cmMakefile::AddDefineFlag(const char* flag)
@ -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);

72
Source/cmMakefile.h
View File

@ -131,45 +131,24 @@ public:
*/
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 std::vector<std::string>& depends,
const char* main_dependency,
const std::vector<std::string>& depends,
const char *comment = 0,
bool replace = false);
void AddCustomCommandToTarget(const char* target,
const char* command,
const std::vector<std::string>& commandArgs,
cmTarget::CustomCommandType type,
const char *comment = 0);
void AddCustomCommandToTarget(const char* target,
const char* command,
const std::vector<std::string>& commandArgs,
cmTarget::CustomCommandType type,
const cmCustomCommandLines& commandLines,
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,
bool replace = false);
void AddCustomCommandOldStyle(const char* target,
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);
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,
const char* command,
const char* arguments,
bool all,
void AddUtilityCommand(const char* utilityName, bool all,
const char* output,
const std::vector<std::string>& depends,
const std::vector<std::string> &outputs);
const char* command,
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.

39
Source/cmQTWrapCPPCommand.cxx
View File

@ -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;
cmCustomCommandLine commandLine;
commandLine.push_back(moc_exe);
commandLine.push_back("-o");
commandLine.push_back(res);
commandLine.push_back(m_WrapHeaders[classNum]);
std::vector<std::string> args;
args.push_back("-o");
args.push_back(res);
args.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,
const char* no_main_dependency = 0;
m_Makefile->AddCustomCommandToOutput(res.c_str(),
realdepends,
"QT Wrapped File",
0);
no_main_dependency,
commandLines,
"QT Wrapped File");
}
m_Makefile->AddDefinition("GENERATED_QT_FILES",moc_list.c_str());
}

88
Source/cmQTWrapUICommand.cxx
View File

@ -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;
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);
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 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());
}

90
Source/cmVTKWrapJavaCommand.cxx
View File

@ -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);
commandLineW.push_back((m_WrapClasses[classNum].GetPropertyAsBool("ABSTRACT") ? "0" : "1"));
commandLineW.push_back(res);
m_Makefile->AddCustomCommand(m_WrapHeaders[classNum].c_str(),
wjava.c_str(), args, depends,
res.c_str(), m_LibraryName.c_str());
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);
std::vector<std::string> args2;
args2.push_back(m_WrapHeaders[classNum]);
if (strcmp("${VTK_WRAP_HINTS}",hints.c_str()))
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);
commandLineP.push_back((m_WrapClasses[classNum].GetPropertyAsBool("ABSTRACT") ? "0" : "1"));
commandLineP.push_back(res2);
m_Makefile->AddCustomCommand(m_WrapHeaders[classNum].c_str(),
pjava.c_str(), args2, depends2,
res2.c_str(), m_LibraryName.c_str());
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, "");
}

35
Source/cmVTKWrapPythonCommand.cxx
View File

@ -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);
commandLine.push_back((m_WrapClasses[classNum].GetPropertyAsBool("ABSTRACT") ? "0" : "1"));
commandLine.push_back(res);
m_Makefile->AddCustomCommand(m_WrapHeaders[classNum].c_str(),
wpython.c_str(), args, depends,
res.c_str(), m_LibraryName.c_str());
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);
}
}

35
Source/cmVTKWrapTclCommand.cxx
View File

@ -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);
commandLine.push_back(res);
m_Makefile->AddCustomCommand(m_WrapHeaders[classNum].c_str(),
wtcl.c_str(), args, depends,
res.c_str(), m_LibraryName.c_str());
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);
}
}