CMake/Source/cmCommand.h

196 lines
5.0 KiB
C
Raw Normal View History

/*============================================================================
CMake - Cross Platform Makefile Generator
Copyright 2000-2009 Kitware, Inc., Insight Software Consortium
Distributed under the OSI-approved BSD License (the "License");
see accompanying file Copyright.txt for details.
This software is distributed WITHOUT ANY WARRANTY; without even the
implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the License for more information.
============================================================================*/
2001-01-18 19:20:24 +03:00
#ifndef cmCommand_h
#define cmCommand_h
#include "cmObject.h"
#include "cmListFileCache.h"
#include "cmMakefile.h"
#include "cmCommandArgumentsHelper.h"
2001-01-18 19:20:24 +03:00
/** \class cmCommand
* \brief Superclass for all commands in CMake.
*
2001-01-18 19:20:24 +03:00
* cmCommand is the base class for all commands in CMake. A command
* manifests as an entry in CMakeLists.txt and produces one or
* more makefile rules. Commands are associated with a particular
* makefile. This base class cmCommand defines the API for commands
* to support such features as enable/disable, inheritance,
2001-01-18 19:20:24 +03:00
* documentation, and construction.
*/
class cmCommand : public cmObject
{
public:
cmTypeMacro(cmCommand, cmObject);
/**
2001-01-18 19:20:24 +03:00
* Construct the command. By default it is enabled with no makefile.
*/
cmCommand()
2006-03-15 19:02:08 +03:00
{this->Makefile = 0; this->Enabled = true;}
/**
* Need virtual destructor to destroy real command type.
*/
virtual ~cmCommand() {}
/**
* Specify the makefile.
*/
void SetMakefile(cmMakefile*m)
2006-03-15 19:02:08 +03:00
{this->Makefile = m; }
cmMakefile* GetMakefile() { return this->Makefile; }
/**
* This is called by the cmMakefile when the command is first
* encountered in the CMakeLists.txt file. It expands the command's
* arguments and then invokes the InitialPass.
*/
virtual bool InvokeInitialPass(const std::vector<cmListFileArgument>& args,
cmExecutionStatus &status)
{
std::vector<std::string> expandedArguments;
if(!this->Makefile->ExpandArguments(args, expandedArguments))
{
// There was an error expanding arguments. It was already
// reported, so we can skip this command without error.
return true;
}
return this->InitialPass(expandedArguments,status);
}
/**
2001-01-18 19:20:24 +03:00
* This is called when the command is first encountered in
* the CMakeLists.txt file.
*/
virtual bool InitialPass(std::vector<std::string> const& args,
cmExecutionStatus &) = 0;
/**
* This is called at the end after all the information
2001-01-18 19:20:24 +03:00
* specified by the command is accumulated. Most commands do
* not implement this method. At this point, reading and
* writing to the cache can be done.
*/
virtual void FinalPass() {}
/**
* Does this command have a final pass? Query after InitialPass.
*/
virtual bool HasFinalPass() const { return false; }
/**
2001-01-18 19:20:24 +03:00
* This is a virtual constructor for the command.
*/
2001-01-18 19:20:24 +03:00
virtual cmCommand* Clone() = 0;
/**
* This determines if the command is invoked when in script mode.
*/
virtual bool IsScriptable() const
{
return false;
}
/**
* This is used to avoid including this command
* in documentation. This is mainly used by
* cmMacroHelperCommand and cmFunctionHelperCommand
* which cannot provide appropriate documentation.
*/
virtual bool ShouldAppearInDocumentation() const
{
return true;
}
/**
2001-01-18 19:20:24 +03:00
* The name of the command as specified in CMakeList.txt.
*/
2014-02-25 05:19:17 +04:00
virtual std::string GetName() const = 0;
/**
2001-01-18 19:20:24 +03:00
* Enable the command.
*/
void EnabledOn()
2006-03-15 19:02:08 +03:00
{this->Enabled = true;}
/**
2001-01-18 19:20:24 +03:00
* Disable the command.
*/
void EnabledOff()
2006-03-15 19:02:08 +03:00
{this->Enabled = false;}
/**
2001-01-18 19:20:24 +03:00
* Query whether the command is enabled.
*/
bool GetEnabled() const
2006-03-15 19:02:08 +03:00
{return this->Enabled;}
2001-01-18 19:20:24 +03:00
/**
* Disable or enable the command.
*/
void SetEnabled(bool enabled)
2006-03-15 19:02:08 +03:00
{this->Enabled = enabled;}
2001-01-18 19:20:24 +03:00
/**
* Return the last error string.
*/
const char* GetError()
{
if(this->Error.empty())
{
2006-03-15 19:02:08 +03:00
this->Error = this->GetName();
this->Error += " unknown error.";
}
2006-03-15 19:02:08 +03:00
return this->Error.c_str();
}
/**
* Set the error message
*/
void SetError(const std::string& e)
{
2006-03-15 19:02:08 +03:00
this->Error = this->GetName();
this->Error += " ";
this->Error += e;
}
/** Check if the command is disallowed by a policy. */
bool Disallowed(cmPolicies::PolicyID pol, const char* e)
{
switch(this->Makefile->GetPolicyStatus(pol))
{
case cmPolicies::WARN:
this->Makefile->IssueMessage(cmake::AUTHOR_WARNING,
2015-05-03 11:12:10 +03:00
cmPolicies::GetPolicyWarning(pol));
case cmPolicies::OLD:
return false;
case cmPolicies::REQUIRED_IF_USED:
case cmPolicies::REQUIRED_ALWAYS:
case cmPolicies::NEW:
this->Makefile->IssueMessage(cmake::FATAL_ERROR, e);
break;
}
return true;
}
protected:
2006-03-15 19:02:08 +03:00
cmMakefile* Makefile;
cmCommandArgumentsHelper Helper;
private:
2006-03-15 19:02:08 +03:00
bool Enabled;
std::string Error;
};
#endif