CMake/Source/cmSetCommand.cxx

179 lines
5.2 KiB
C++
Raw Normal View History

/*============================================================================
CMake - Cross Platform Makefile Generator
Copyright 2000-2009 Kitware, Inc., Insight Software Consortium
2001-05-01 19:16:20 +04:00
Distributed under the OSI-approved BSD License (the "License");
see accompanying file Copyright.txt for details.
2001-05-01 19:16:20 +04:00
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-05-01 19:16:20 +04:00
#include "cmSetCommand.h"
// cmSetCommand
bool cmSetCommand
::InitialPass(std::vector<std::string> const& args, cmExecutionStatus &)
2001-05-01 19:16:20 +04:00
{
if(args.size() < 1 )
{
this->SetError("called with incorrect number of arguments");
return false;
}
// watch for ENV signatures
const char* variable = args[0].c_str(); // VAR is always first
2013-11-20 05:12:00 +04:00
if (cmHasLiteralPrefix(variable, "ENV{") && strlen(variable) > 5)
{
// what is the variable name
char *varName = new char [strlen(variable)];
strncpy(varName,variable+4,strlen(variable)-5);
varName[strlen(variable)-5] = '\0';
std::string putEnvArg = varName;
putEnvArg += "=";
// what is the current value if any
const char *currValue = getenv(varName);
2005-06-03 22:17:59 +04:00
delete [] varName;
// will it be set to something, then set it
if (args.size() > 1 && args[1].size())
{
// but only if it is different from current value
if (!currValue || strcmp(currValue,args[1].c_str()))
{
putEnvArg += args[1];
cmSystemTools::PutEnv(putEnvArg.c_str());
}
return true;
}
// if it will be cleared, then clear it if it isn;t already clear
if (currValue)
{
cmSystemTools::PutEnv(putEnvArg.c_str());
}
return true;
}
// SET (VAR) // Removes the definition of VAR.
2001-05-01 19:16:20 +04:00
if (args.size() == 1)
{
2006-03-15 19:02:08 +03:00
this->Makefile->RemoveDefinition(args[0].c_str());
return true;
2001-05-01 19:16:20 +04:00
}
// SET (VAR PARENT_SCOPE) // Removes the definition of VAR
// in the parent scope.
else if (args.size() == 2 && args[args.size()-1] == "PARENT_SCOPE")
{
this->Makefile->RaiseScope(variable, 0);
return true;
}
// here are the remaining options
// SET (VAR value )
// SET (VAR value PARENT_SCOPE)
// SET (VAR CACHE TYPE "doc String" [FORCE])
// SET (VAR value CACHE TYPE "doc string" [FORCE])
std::string value; // optional
bool cache = false; // optional
2002-10-09 23:48:59 +04:00
bool force = false; // optional
bool parentScope = false;
cmCacheManager::CacheEntryType type
= cmCacheManager::STRING; // required if cache
const char* docstring = 0; // required if cache
unsigned int ignoreLastArgs = 0;
// look for PARENT_SCOPE argument
if (args.size() > 1 && args[args.size()-1] == "PARENT_SCOPE")
2002-10-09 23:48:59 +04:00
{
parentScope = true;
ignoreLastArgs++;
2002-10-09 23:48:59 +04:00
}
else
{
// look for FORCE argument
if (args.size() > 4 && args[args.size()-1] == "FORCE")
{
force = true;
ignoreLastArgs++;
}
// check for cache signature
if (args.size() > 3 && args[args.size() - 3 - (force ? 1 : 0)] == "CACHE")
{
cache = true;
ignoreLastArgs+=3;
}
2001-05-16 23:15:21 +04:00
}
// collect any values into a single semi-colon separated value list
if(static_cast<unsigned short>(args.size()) >
static_cast<unsigned short>(1 + ignoreLastArgs))
2001-05-01 19:16:20 +04:00
{
value = args[1];
size_t endPos = args.size() - ignoreLastArgs;
for(size_t i = 2; i < endPos; ++i)
{
value += ";";
value += args[i];
}
}
if (parentScope)
{
this->Makefile->RaiseScope(variable, value.c_str());
return true;
}
// we should be nice and try to catch some simple screwups if the last or
// next to last args are CACHE then they screwed up. If they used FORCE
// without CACHE they screwed up
if ((args[args.size() - 1] == "CACHE") ||
(args.size() > 1 && args[args.size() - 2] == "CACHE") ||
(force && !cache))
2001-06-05 02:23:58 +04:00
{
this->SetError("given invalid arguments for CACHE mode.");
2001-06-05 02:23:58 +04:00
return false;
}
if(cache)
{
std::string::size_type cacheStart = args.size() - 3 - (force ? 1 : 0);
type = cmCacheManager::StringToType(args[cacheStart+1].c_str());
docstring = args[cacheStart+2].c_str();
}
// see if this is already in the cache
cmCacheManager::CacheIterator it =
2006-03-15 19:02:08 +03:00
this->Makefile->GetCacheManager()->GetCacheIterator(variable);
if(!it.IsAtEnd() && (it.GetType() != cmCacheManager::UNINITIALIZED))
{
// if the set is trying to CACHE the value but the value
// is already in the cache and the type is not internal
// then leave now without setting any definitions in the cache
// or the makefile
2002-10-09 23:48:59 +04:00
if(cache && type != cmCacheManager::INTERNAL && !force)
{
return true;
}
}
// if it is meant to be in the cache then define it in the cache
if(cache)
{
2006-03-15 19:02:08 +03:00
this->Makefile->AddCacheDefinition(variable,
value.c_str(),
docstring,
2008-11-22 00:32:39 +03:00
type, force);
}
else
{
// add the definition
2006-03-15 19:02:08 +03:00
this->Makefile->AddDefinition(variable, value.c_str());
2001-05-01 19:16:20 +04:00
}
return true;
}