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

ENH: add functions and raise scope to cmake

This commit is contained in:
Ken Martin 2007-12-03 12:44:42 -05:00
parent 50bdabde07
commit 951444165f
6 changed files with 597 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

277
Source/cmFunctionCommand.cxx Normal file
View File

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

112
Source/cmFunctionCommand.h Normal file
View File

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

30
Source/cmRaiseScopeCommand.cxx Normal file
View File

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

85
Source/cmRaiseScopeCommand.h Normal file
View File

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

86
Tests/FunctionTest/CMakeLists.txt Normal file
View File

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

7
Tests/FunctionTest/functionTest.c Normal file
View File

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