ENH: add functions and raise scope to cmake
This commit is contained in:
Ken Martin
parent
50bdabde07
commit
951444165f
|
|
@ -0,0 +1,277 @@
|
|||
/*=========================================================================
|
||||
|
||||
Program: CMake - Cross-Platform Makefile Generator
|
||||
Module: $RCSfile$
|
||||
Language: C++
|
||||
Date: $Date$
|
||||
Version: $Revision$
|
||||
|
||||
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
|
||||
PURPOSE. See the above copyright notices for more information.
|
||||
|
||||
=========================================================================*/
|
||||
#include "cmFunctionCommand.h"
|
||||
|
||||
#include "cmake.h"
|
||||
|
||||
// define the class for function commands
|
||||
class cmFunctionHelperCommand : public cmCommand
|
||||
{
|
||||
public:
|
||||
cmFunctionHelperCommand() {}
|
||||
|
||||
///! clean up any memory allocated by the function
|
||||
~cmFunctionHelperCommand() {};
|
||||
|
||||
/**
|
||||
* This is a virtual constructor for the command.
|
||||
*/
|
||||
virtual cmCommand* Clone()
|
||||
{
|
||||
cmFunctionHelperCommand *newC = new cmFunctionHelperCommand;
|
||||
// we must copy when we clone
|
||||
newC->Args = this->Args;
|
||||
newC->Functions = this->Functions;
|
||||
return newC;
|
||||
}
|
||||
|
||||
/**
|
||||
* This determines if the command is invoked when in script mode.
|
||||
*/
|
||||
virtual bool IsScriptable() { return true; }
|
||||
|
||||
/**
|
||||
* This is called when the command is first encountered in
|
||||
* the CMakeLists.txt file.
|
||||
*/
|
||||
virtual bool InvokeInitialPass(const std::vector<cmListFileArgument>& args);
|
||||
|
||||
virtual bool InitialPass(std::vector<std::string> const&) { return false; };
|
||||
|
||||
/**
|
||||
* The name of the command as specified in CMakeList.txt.
|
||||
*/
|
||||
virtual const char* GetName() { return this->Args[0].c_str(); }
|
||||
|
||||
/**
|
||||
* Succinct documentation.
|
||||
*/
|
||||
virtual const char* GetTerseDocumentation()
|
||||
{
|
||||
std::string docs = "Function named: ";
|
||||
docs += this->GetName();
|
||||
return docs.c_str();
|
||||
}
|
||||
|
||||
/**
|
||||
* More documentation.
|
||||
*/
|
||||
virtual const char* GetFullDocumentation()
|
||||
{
|
||||
return this->GetTerseDocumentation();
|
||||
}
|
||||
|
||||
cmTypeMacro(cmFunctionHelperCommand, cmCommand);
|
||||
|
||||
std::vector<std::string> Args;
|
||||
std::vector<cmListFileFunction> Functions;
|
||||
};
|
||||
|
||||
|
||||
bool cmFunctionHelperCommand::InvokeInitialPass
|
||||
(const std::vector<cmListFileArgument>& args)
|
||||
{
|
||||
// Expand the argument list to the function.
|
||||
std::vector<std::string> expandedArgs;
|
||||
this->Makefile->ExpandArguments(args, expandedArgs);
|
||||
|
||||
// make sure the number of arguments passed is at least the number
|
||||
// required by the signature
|
||||
if (expandedArgs.size() < this->Args.size() - 1)
|
||||
{
|
||||
std::string errorMsg =
|
||||
"Function invoked with incorrect arguments for function named: ";
|
||||
errorMsg += this->Args[0];
|
||||
this->SetError(errorMsg.c_str());
|
||||
return false;
|
||||
}
|
||||
|
||||
// we push a scope on the makefile
|
||||
this->Makefile->PushScope();
|
||||
|
||||
// set the value of argc
|
||||
cmOStringStream strStream;
|
||||
strStream << expandedArgs.size();
|
||||
this->Makefile->AddDefinition("ARGC",strStream.str().c_str());
|
||||
|
||||
// set the values for ARGV0 ARGV1 ...
|
||||
for (unsigned int t = 0; t < expandedArgs.size(); ++t)
|
||||
{
|
||||
strStream.str("");
|
||||
strStream << "ARGV" << t;
|
||||
this->Makefile->AddDefinition(strStream.str().c_str(),
|
||||
expandedArgs[t].c_str());
|
||||
}
|
||||
|
||||
// define the formal arguments
|
||||
for (unsigned int j = 1; j < this->Args.size(); ++j)
|
||||
{
|
||||
this->Makefile->AddDefinition(this->Args[j].c_str(),
|
||||
expandedArgs[j-1].c_str());
|
||||
}
|
||||
|
||||
// define ARGV and ARGN
|
||||
std::vector<std::string>::const_iterator eit;
|
||||
std::string argvDef;
|
||||
std::string argnDef;
|
||||
unsigned int cnt = 0;
|
||||
for ( eit = expandedArgs.begin(); eit != expandedArgs.end(); ++eit )
|
||||
{
|
||||
if ( argvDef.size() > 0 )
|
||||
{
|
||||
argvDef += ";";
|
||||
}
|
||||
argvDef += *eit;
|
||||
if ( cnt >= this->Args.size()-1 )
|
||||
{
|
||||
if ( argnDef.size() > 0 )
|
||||
{
|
||||
argnDef += ";";
|
||||
}
|
||||
argnDef += *eit;
|
||||
}
|
||||
cnt ++;
|
||||
}
|
||||
this->Makefile->AddDefinition("ARGV", argvDef.c_str());
|
||||
this->Makefile->AddDefinition("ARGN", argnDef.c_str());
|
||||
|
||||
// Invoke all the functions that were collected in the block.
|
||||
cmListFileFunction newLFF;
|
||||
|
||||
// for each function
|
||||
for(unsigned int c = 0; c < this->Functions.size(); ++c)
|
||||
{
|
||||
if (!this->Makefile->ExecuteCommand(this->Functions[c]))
|
||||
{
|
||||
cmOStringStream error;
|
||||
error << "Error in cmake code at\n"
|
||||
<< this->Functions[c].FilePath << ":"
|
||||
<< this->Functions[c].Line << ":\n"
|
||||
<< "A command failed during the invocation of function \""
|
||||
<< this->Args[0].c_str() << "\".";
|
||||
cmSystemTools::Error(error.str().c_str());
|
||||
|
||||
// pop scope on the makefile and return
|
||||
this->Makefile->PopScope();
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
// pop scope on the makefile
|
||||
this->Makefile->PopScope();
|
||||
return true;
|
||||
}
|
||||
|
||||
bool cmFunctionFunctionBlocker::
|
||||
IsFunctionBlocked(const cmListFileFunction& lff, cmMakefile &mf)
|
||||
{
|
||||
// record commands until we hit the ENDFUNCTION
|
||||
// at the ENDFUNCTION call we shift gears and start looking for invocations
|
||||
if(!cmSystemTools::Strucmp(lff.Name.c_str(),"function"))
|
||||
{
|
||||
this->Depth++;
|
||||
}
|
||||
else if(!cmSystemTools::Strucmp(lff.Name.c_str(),"endfunction"))
|
||||
{
|
||||
// if this is the endfunction for this function then execute
|
||||
if (!this->Depth)
|
||||
{
|
||||
std::string name = this->Args[0];
|
||||
std::vector<std::string>::size_type cc;
|
||||
name += "(";
|
||||
for ( cc = 0; cc < this->Args.size(); cc ++ )
|
||||
{
|
||||
name += " " + this->Args[cc];
|
||||
}
|
||||
name += " )";
|
||||
|
||||
// create a new command and add it to cmake
|
||||
cmFunctionHelperCommand *f = new cmFunctionHelperCommand();
|
||||
f->Args = this->Args;
|
||||
f->Functions = this->Functions;
|
||||
std::string newName = "_" + this->Args[0];
|
||||
mf.GetCMakeInstance()->RenameCommand(this->Args[0].c_str(),
|
||||
newName.c_str());
|
||||
mf.AddCommand(f);
|
||||
|
||||
// remove the function blocker now that the function is defined
|
||||
mf.RemoveFunctionBlocker(lff);
|
||||
return true;
|
||||
}
|
||||
else
|
||||
{
|
||||
// decrement for each nested function that ends
|
||||
this->Depth--;
|
||||
}
|
||||
}
|
||||
|
||||
// if it wasn't an endfunction and we are not executing then we must be
|
||||
// recording
|
||||
this->Functions.push_back(lff);
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
bool cmFunctionFunctionBlocker::
|
||||
ShouldRemove(const cmListFileFunction& lff, cmMakefile &mf)
|
||||
{
|
||||
if(!cmSystemTools::Strucmp(lff.Name.c_str(),"endfunction"))
|
||||
{
|
||||
std::vector<std::string> expandedArguments;
|
||||
mf.ExpandArguments(lff.Arguments, expandedArguments);
|
||||
if ((!expandedArguments.empty() &&
|
||||
(expandedArguments[0] == this->Args[0]))
|
||||
|| cmSystemTools::IsOn
|
||||
(mf.GetPropertyOrDefinition("CMAKE_ALLOW_LOOSE_LOOP_CONSTRUCTS")))
|
||||
{
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
void cmFunctionFunctionBlocker::
|
||||
ScopeEnded(cmMakefile &mf)
|
||||
{
|
||||
// functions should end with an EndFunction
|
||||
cmSystemTools::Error(
|
||||
"The end of a CMakeLists file was reached with a FUNCTION statement that "
|
||||
"was not closed properly. Within the directory: ",
|
||||
mf.GetCurrentDirectory(), " with function ",
|
||||
this->Args[0].c_str());
|
||||
}
|
||||
|
||||
bool cmFunctionCommand::InitialPass(std::vector<std::string> const& args)
|
||||
{
|
||||
if(args.size() < 1)
|
||||
{
|
||||
this->SetError("called with incorrect number of arguments");
|
||||
return false;
|
||||
}
|
||||
|
||||
// create a function blocker
|
||||
cmFunctionFunctionBlocker *f = new cmFunctionFunctionBlocker();
|
||||
for(std::vector<std::string>::const_iterator j = args.begin();
|
||||
j != args.end(); ++j)
|
||||
{
|
||||
f->Args.push_back(*j);
|
||||
}
|
||||
this->Makefile->AddFunctionBlocker(f);
|
||||
return true;
|
||||
}
|
||||
|
||||
|
|
@ -0,0 +1,112 @@
|
|||
/*=========================================================================
|
||||
|
||||
Program: CMake - Cross-Platform Makefile Generator
|
||||
Module: $RCSfile$
|
||||
Language: C++
|
||||
Date: $Date$
|
||||
Version: $Revision$
|
||||
|
||||
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
|
||||
PURPOSE. See the above copyright notices for more information.
|
||||
|
||||
=========================================================================*/
|
||||
#ifndef cmFunctionCommand_h
|
||||
#define cmFunctionCommand_h
|
||||
|
||||
#include "cmCommand.h"
|
||||
#include "cmFunctionBlocker.h"
|
||||
|
||||
/** \class cmFunctionFunctionBlocker
|
||||
* \brief subclass of function blocker
|
||||
*
|
||||
*
|
||||
*/
|
||||
class cmFunctionFunctionBlocker : public cmFunctionBlocker
|
||||
{
|
||||
public:
|
||||
cmFunctionFunctionBlocker() {this->Depth=0;}
|
||||
virtual ~cmFunctionFunctionBlocker() {}
|
||||
virtual bool IsFunctionBlocked(const cmListFileFunction&, cmMakefile &mf);
|
||||
virtual bool ShouldRemove(const cmListFileFunction&, cmMakefile &mf);
|
||||
virtual void ScopeEnded(cmMakefile &mf);
|
||||
|
||||
std::vector<std::string> Args;
|
||||
std::vector<cmListFileFunction> Functions;
|
||||
int Depth;
|
||||
};
|
||||
|
||||
/** \class cmFunctionCommand
|
||||
* \brief starts an if block
|
||||
*
|
||||
* cmFunctionCommand starts an if block
|
||||
*/
|
||||
class cmFunctionCommand : public cmCommand
|
||||
{
|
||||
public:
|
||||
/**
|
||||
* This is a virtual constructor for the command.
|
||||
*/
|
||||
virtual cmCommand* Clone()
|
||||
{
|
||||
return new cmFunctionCommand;
|
||||
}
|
||||
|
||||
/**
|
||||
* This is called when the command is first encountered in
|
||||
* the CMakeLists.txt file.
|
||||
*/
|
||||
virtual bool InitialPass(std::vector<std::string> const& args);
|
||||
|
||||
/**
|
||||
* This determines if the command is invoked when in script mode.
|
||||
*/
|
||||
virtual bool IsScriptable() { return true; }
|
||||
|
||||
/**
|
||||
* The name of the command as specified in CMakeList.txt.
|
||||
*/
|
||||
virtual const char* GetName() { return "function";}
|
||||
|
||||
/**
|
||||
* Succinct documentation.
|
||||
*/
|
||||
virtual const char* GetTerseDocumentation()
|
||||
{
|
||||
return "Start recording a function for later invocation as a command.";
|
||||
}
|
||||
|
||||
/**
|
||||
* More documentation.
|
||||
*/
|
||||
virtual const char* GetFullDocumentation()
|
||||
{
|
||||
return
|
||||
" function(<name> [arg1 [arg2 [arg3 ...]]])\n"
|
||||
" COMMAND1(ARGS ...)\n"
|
||||
" COMMAND2(ARGS ...)\n"
|
||||
" ...\n"
|
||||
" endfunction(<name>)\n"
|
||||
"Define a function named <name> that takes arguments named "
|
||||
"arg1 arg2 arg3 (...). Commands listed after function, "
|
||||
"but before the matching endfunction, are not invoked until the function "
|
||||
"is invoked. When it is invoked, the commands recorded in the "
|
||||
"function are first modified by replacing formal parameters (${arg1}) "
|
||||
"with the arguments passed, and then invoked as normal commands. In "
|
||||
"addition to referencing the formal parameters you can reference "
|
||||
"the variable ARGC which will be set to the number of arguments "
|
||||
"passed into the function as well as ARGV0 ARGV1 ARGV2 ... which "
|
||||
"will have the actual values of the arguments passed in. This "
|
||||
"facilitates creating functions with optional arguments. Additionally "
|
||||
"ARGV holds the list of all arguments given to the function and ARGN "
|
||||
"holds the list of argument pass the last expected argument.";
|
||||
}
|
||||
|
||||
cmTypeMacro(cmFunctionCommand, cmCommand);
|
||||
};
|
||||
|
||||
|
||||
#endif
|
||||
|
|
@ -0,0 +1,30 @@
|
|||
/*=========================================================================
|
||||
|
||||
Program: CMake - Cross-Platform Makefile Generator
|
||||
Module: $RCSfile$
|
||||
Language: C++
|
||||
Date: $Date$
|
||||
Version: $Revision$
|
||||
|
||||
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
|
||||
PURPOSE. See the above copyright notices for more information.
|
||||
|
||||
=========================================================================*/
|
||||
#include "cmRaiseScopeCommand.h"
|
||||
|
||||
// cmRaiseScopeCommand
|
||||
bool cmRaiseScopeCommand
|
||||
::InitialPass(std::vector<std::string> const& args)
|
||||
{
|
||||
unsigned int i =0;
|
||||
for(; i < args.size(); ++i)
|
||||
{
|
||||
this->Makefile->RaiseScope(args[i].c_str());
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
|
|
@ -0,0 +1,85 @@
|
|||
/*=========================================================================
|
||||
|
||||
Program: CMake - Cross-Platform Makefile Generator
|
||||
Module: $RCSfile$
|
||||
Language: C++
|
||||
Date: $Date$
|
||||
Version: $Revision$
|
||||
|
||||
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
|
||||
PURPOSE. See the above copyright notices for more information.
|
||||
|
||||
=========================================================================*/
|
||||
#ifndef cmRaiseScopeCommand_h
|
||||
#define cmRaiseScopeCommand_h
|
||||
|
||||
#include "cmCommand.h"
|
||||
|
||||
/** \class cmRaiseScopeCommand
|
||||
* \brief Raise the Scope a CMAKE variable one level up
|
||||
*
|
||||
* cmRaiseScopeCommand pushes the current state of a variable into
|
||||
* the scope above the current scope.
|
||||
*/
|
||||
class cmRaiseScopeCommand : public cmCommand
|
||||
{
|
||||
public:
|
||||
/**
|
||||
* This is a virtual constructor for the command.
|
||||
*/
|
||||
virtual cmCommand* Clone()
|
||||
{
|
||||
return new cmRaiseScopeCommand;
|
||||
}
|
||||
|
||||
/**
|
||||
* This is called when the command is first encountered in
|
||||
* the CMakeLists.txt file.
|
||||
*/
|
||||
virtual bool InitialPass(std::vector<std::string> const& args);
|
||||
|
||||
/**
|
||||
* The name of the command as specified in CMakeList.txt.
|
||||
*/
|
||||
virtual const char* GetName() {return "raise_scope";}
|
||||
|
||||
/**
|
||||
* Succinct documentation.
|
||||
*/
|
||||
virtual const char* GetTerseDocumentation()
|
||||
{
|
||||
return "Raise the scope of the variables listed.";
|
||||
}
|
||||
|
||||
/**
|
||||
* More documentation.
|
||||
*/
|
||||
virtual const char* GetFullDocumentation()
|
||||
{
|
||||
return
|
||||
" raise_scope(VAR VAR2 VAR...)\n"
|
||||
"Pushes the current state of a variable into the scope above the "
|
||||
"current scope. Each new directory or function creates a new scope. "
|
||||
"This command will push the current state of a variable into the "
|
||||
"parent directory or calling function (whichever is applicable to "
|
||||
"the case at hand)";
|
||||
}
|
||||
|
||||
/**
|
||||
* This determines if the command is invoked when in script mode.
|
||||
* mark_as_advanced() will have no effect in script mode, but this will
|
||||
* make many of the modules usable in cmake/ctest scripts, (among them
|
||||
* FindUnixMake.cmake used by the CTEST_BUILD command.
|
||||
*/
|
||||
virtual bool IsScriptable() { return true; }
|
||||
|
||||
cmTypeMacro(cmRaiseScopeCommand, cmCommand);
|
||||
};
|
||||
|
||||
|
||||
|
||||
#endif
|
||||
|
|
@ -0,0 +1,86 @@
|
|||
# a simple C only test case
|
||||
PROJECT (FunctionTest)
|
||||
|
||||
SET(CMAKE_C_FLAGS "${CMAKE_ANSI_CFLAGS} ${CMAKE_C_FLAGS}")
|
||||
|
||||
FUNCTION(FAILED testname)
|
||||
MESSAGE(SEND_ERROR "${testname} failed ${ARGN}")
|
||||
ENDFUNCTION(FAILED)
|
||||
|
||||
FUNCTION(PASS testname)
|
||||
MESSAGE("${testname} passed ${ARGN}")
|
||||
ENDFUNCTION(PASS)
|
||||
|
||||
|
||||
# test scope
|
||||
SET(COUNT 3)
|
||||
FUNCTION(scope_test)
|
||||
SET(COUNT 4)
|
||||
ENDFUNCTION(scope_test)
|
||||
scope_test()
|
||||
IF(COUNT EQUAL "3")
|
||||
PASS("scope")
|
||||
ELSE(COUNT EQUAL "3")
|
||||
FAILED("COUNT Got: ${COUNT}")
|
||||
ENDIF(COUNT EQUAL "3")
|
||||
|
||||
# test ARGC
|
||||
FUNCTION(weird_name)
|
||||
IF("${ARGC}" EQUAL "3")
|
||||
PASS("ARGC")
|
||||
ELSE("${ARGC}" EQUAL "3")
|
||||
FAILED("ARGC" "Got: ${ARGC}")
|
||||
ENDIF("${ARGC}" EQUAL "3")
|
||||
ENDFUNCTION(weird_name)
|
||||
WeIrD_nAmE(a1 a2 a3)
|
||||
|
||||
# test ARGN
|
||||
FUNCTION(test_argn_function argument)
|
||||
IF("${ARGN}" EQUAL "3")
|
||||
PASS("ARGN")
|
||||
ELSE("${ARGN}" EQUAL "3")
|
||||
FAILED("ARGN" "Got: ${ARGN}")
|
||||
ENDIF("${ARGN}" EQUAL "3")
|
||||
ENDFUNCTION(test_argn_function)
|
||||
Test_Argn_Function(ignored 3)
|
||||
|
||||
# test recursion and return via raise_scope
|
||||
function (factorial argument result)
|
||||
if (argument LESS 2)
|
||||
set (${result} 1)
|
||||
else (argument LESS 2)
|
||||
math (EXPR temp "${argument} - 1")
|
||||
factorial (${temp} tresult)
|
||||
math (EXPR ${result} "${argument}*${tresult}")
|
||||
endif (argument LESS 2)
|
||||
raise_scope (${result})
|
||||
endfunction (factorial)
|
||||
|
||||
factorial (5 fresult)
|
||||
if (fresult EQUAL 120)
|
||||
pass("factorial")
|
||||
else (fresult EQUAL 120)
|
||||
failed ("factorial, computed ${fresult} instead of 120")
|
||||
endif (fresult EQUAL 120)
|
||||
|
||||
|
||||
|
||||
# case test
|
||||
FUNCTION(strange_function m)
|
||||
SET(${m} strange_function)
|
||||
RAISE_SCOPE(${m})
|
||||
ENDFUNCTION(strange_function m)
|
||||
STRANGE_FUNCTION(var)
|
||||
set(second_var "second_var")
|
||||
IF("${var}" STREQUAL "strange_function" AND "${second_var}" STREQUAL "second_var")
|
||||
PASS("Case Test" "(${var} ${second_var})")
|
||||
ELSE("${var}" STREQUAL "strange_function" AND "${second_var}" STREQUAL "second_var")
|
||||
FAILED("Case test" "(${var} ${second_var})")
|
||||
ENDIF("${var}" STREQUAL "strange_function" AND "${second_var}" STREQUAL "second_var")
|
||||
|
||||
# test backing up command
|
||||
FUNCTION(ADD_EXECUTABLE exec)
|
||||
_ADD_EXECUTABLE(mini${exec} ${ARGN})
|
||||
ENDFUNCTION(ADD_EXECUTABLE)
|
||||
|
||||
ADD_EXECUTABLE(FunctionTest functionTest.c)
|
||||
|
|
@ -0,0 +1,7 @@
|
|||
#include <stdio.h>
|
||||
|
||||
int main(int argc, char* argv[])
|
||||
{
|
||||
printf("Running command: %s with %d arguments\n", argv[0], argc);
|
||||
return 0;
|
||||
}
|
||||
Loading…
Reference in New Issue