From 951444165f4c18c83efe47f8e86656df9c690983 Mon Sep 17 00:00:00 2001 From: Ken Martin Date: Mon, 3 Dec 2007 12:44:42 -0500 Subject: ENH: add functions and raise scope to cmake --- Source/cmFunctionCommand.cxx | 277 ++++++++++++++++++++++++++++++++++++++ Source/cmFunctionCommand.h | 112 +++++++++++++++ Source/cmRaiseScopeCommand.cxx | 30 +++++ Source/cmRaiseScopeCommand.h | 85 ++++++++++++ Tests/FunctionTest/CMakeLists.txt | 86 ++++++++++++ Tests/FunctionTest/functionTest.c | 7 + 6 files changed, 597 insertions(+) create mode 100644 Source/cmFunctionCommand.cxx create mode 100644 Source/cmFunctionCommand.h create mode 100644 Source/cmRaiseScopeCommand.cxx create mode 100644 Source/cmRaiseScopeCommand.h create mode 100644 Tests/FunctionTest/CMakeLists.txt create mode 100644 Tests/FunctionTest/functionTest.c diff --git a/Source/cmFunctionCommand.cxx b/Source/cmFunctionCommand.cxx new file mode 100644 index 0000000..a95c04d --- /dev/null +++ b/Source/cmFunctionCommand.cxx @@ -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& args); + + virtual bool InitialPass(std::vector 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 Args; + std::vector Functions; +}; + + +bool cmFunctionHelperCommand::InvokeInitialPass +(const std::vector& args) +{ + // Expand the argument list to the function. + std::vector 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::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::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 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 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::const_iterator j = args.begin(); + j != args.end(); ++j) + { + f->Args.push_back(*j); + } + this->Makefile->AddFunctionBlocker(f); + return true; +} + diff --git a/Source/cmFunctionCommand.h b/Source/cmFunctionCommand.h new file mode 100644 index 0000000..908a668 --- /dev/null +++ b/Source/cmFunctionCommand.h @@ -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 Args; + std::vector 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 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( [arg1 [arg2 [arg3 ...]]])\n" + " COMMAND1(ARGS ...)\n" + " COMMAND2(ARGS ...)\n" + " ...\n" + " endfunction()\n" + "Define a function named 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 diff --git a/Source/cmRaiseScopeCommand.cxx b/Source/cmRaiseScopeCommand.cxx new file mode 100644 index 0000000..ffaff8e --- /dev/null +++ b/Source/cmRaiseScopeCommand.cxx @@ -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 const& args) +{ + unsigned int i =0; + for(; i < args.size(); ++i) + { + this->Makefile->RaiseScope(args[i].c_str()); + } + return true; +} + diff --git a/Source/cmRaiseScopeCommand.h b/Source/cmRaiseScopeCommand.h new file mode 100644 index 0000000..51d4f1f --- /dev/null +++ b/Source/cmRaiseScopeCommand.h @@ -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 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 diff --git a/Tests/FunctionTest/CMakeLists.txt b/Tests/FunctionTest/CMakeLists.txt new file mode 100644 index 0000000..76c2511 --- /dev/null +++ b/Tests/FunctionTest/CMakeLists.txt @@ -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) diff --git a/Tests/FunctionTest/functionTest.c b/Tests/FunctionTest/functionTest.c new file mode 100644 index 0000000..e0ced6a --- /dev/null +++ b/Tests/FunctionTest/functionTest.c @@ -0,0 +1,7 @@ +#include + +int main(int argc, char* argv[]) +{ + printf("Running command: %s with %d arguments\n", argv[0], argc); + return 0; +} -- cgit v0.12