CMake/Source/cmIfCommand.cxx

300 lines
7.3 KiB
C++
Raw Normal View History

2001-04-20 01:39:03 +04:00
/*=========================================================================
Program: CMake - Cross-Platform Makefile Generator
2001-04-20 01:39:03 +04:00
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.
2001-04-20 01:39:03 +04:00
2002-01-21 23:30:43 +03:00
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.
2001-04-20 01:39:03 +04:00
=========================================================================*/
#include "cmIfCommand.h"
bool cmIfFunctionBlocker::
IsFunctionBlocked(const cmListFileFunction& lff, cmMakefile &mf)
2001-04-20 01:39:03 +04:00
{
const char* name = lff.m_Name.c_str();
const std::vector<cmListFileArgument>& args = lff.m_Arguments;
2002-09-23 17:41:01 +04:00
// always let if statements through
if (!strcmp(name,"IF"))
{
return false;
}
// watch for our ELSE or ENDIF
2001-05-02 00:27:51 +04:00
if (!strcmp(name,"ELSE") || !strcmp(name,"ENDIF"))
2001-04-20 01:39:03 +04:00
{
2001-08-07 01:01:26 +04:00
if (args == m_Args)
2001-05-01 19:16:20 +04:00
{
2002-08-09 20:00:49 +04:00
// if it was an else statement then we should change state
// and block this Else Command
if (!strcmp(name,"ELSE"))
{
m_IsBlocking = !m_IsBlocking;
return true;
}
2002-09-10 18:16:50 +04:00
// otherwise it must be an ENDIF statement, in that case remove the
// function blocker
mf.RemoveFunctionBlocker(lff);
2002-09-10 18:16:50 +04:00
return true;
2001-05-01 19:16:20 +04:00
}
else if(args.empty())
{
std::string err = "Empty arguments for ";
err += name;
err += ". Did you mean ";
err += name;
err += "( ";
for(std::vector<cmListFileArgument>::const_iterator a = m_Args.begin();
a != m_Args.end();++a)
{
err += (a->Quoted?"\"":"");
err += a->Value;
err += (a->Quoted?"\"":"");
err += " ";
}
err += ")?";
cmSystemTools::Error(err.c_str());
}
2001-04-20 01:39:03 +04:00
}
return m_IsBlocking;
2001-04-20 01:39:03 +04:00
}
bool cmIfFunctionBlocker::ShouldRemove(const cmListFileFunction& lff,
cmMakefile&)
2001-04-20 01:39:03 +04:00
{
if (lff.m_Name == "ENDIF")
{
if (lff.m_Arguments == m_Args)
{
return true;
}
}
return false;
2001-04-20 01:39:03 +04:00
}
2001-05-04 16:46:05 +04:00
void cmIfFunctionBlocker::
2001-07-26 00:53:13 +04:00
ScopeEnded(cmMakefile &mf)
2001-05-04 16:46:05 +04:00
{
2002-09-24 22:49:34 +04:00
const char* versionValue
= mf.GetDefinition("CMAKE_MINIMUM_REQUIRED_VERSION");
if (!versionValue || (atof(versionValue) <= 1.4))
{
return;
}
2001-11-26 19:31:50 +03:00
std::string errmsg = "The end of a CMakeLists file was reached with an IF statement that was not closed properly.\nWithin the directory: ";
errmsg += mf.GetCurrentDirectory();
errmsg += "\nThe arguments are: ";
for(std::vector<cmListFileArgument>::const_iterator j = m_Args.begin();
2001-11-26 19:31:50 +03:00
j != m_Args.end(); ++j)
{
errmsg += (j->Quoted?"\"":"");
errmsg += j->Value;
errmsg += (j->Quoted?"\"":"");
2001-11-26 19:31:50 +03:00
errmsg += " ";
}
cmSystemTools::Error(errmsg.c_str());
2001-05-04 16:46:05 +04:00
}
bool cmIfCommand::InvokeInitialPass(const std::vector<cmListFileArgument>& args)
2001-04-20 01:39:03 +04:00
{
bool isValid;
std::vector<std::string> expandedArguments;
m_Makefile->ExpandArguments(args, expandedArguments);
bool isTrue = cmIfCommand::IsTrue(expandedArguments,isValid,m_Makefile);
if (!isValid)
2001-04-20 01:39:03 +04:00
{
std::string err = "An IF command had incorrect arguments: ";
2002-11-15 20:54:04 +03:00
unsigned int i;
for(i =0; i < args.size(); ++i)
{
err += (args[i].Quoted?"\"":"");
err += args[i].Value;
err += (args[i].Quoted?"\"":"");
err += " ";
}
this->SetError(err.c_str());
2001-04-20 01:39:03 +04:00
return false;
}
cmIfFunctionBlocker *f = new cmIfFunctionBlocker();
// if is isn't true block the commands
f->m_IsBlocking = !isTrue;
f->m_Args = args;
m_Makefile->AddFunctionBlocker(f);
return true;
}
2001-08-07 01:01:26 +04:00
bool cmIfCommand::IsTrue(const std::vector<std::string> &args,
bool &isValid, const cmMakefile *makefile)
{
2001-08-07 01:01:26 +04:00
// check for the different signatures
bool isTrue = true;
isValid = false;
2001-05-01 19:16:20 +04:00
const char *def;
2001-08-07 01:01:26 +04:00
const char *def2;
if(args.size() < 1 )
{
isValid = true;
return false;
}
2001-08-07 01:01:26 +04:00
if (args.size() == 1)
{
def = makefile->GetDefinition(args[0].c_str());
2001-08-07 01:01:26 +04:00
if(cmSystemTools::IsOff(def))
{
isTrue = false;
2001-08-07 01:01:26 +04:00
}
isValid = true;
2001-08-07 01:01:26 +04:00
}
2001-05-01 19:16:20 +04:00
if (args.size() == 2 && (args[0] == "NOT"))
2001-04-20 01:39:03 +04:00
{
def = makefile->GetDefinition(args[1].c_str());
2001-05-01 19:16:20 +04:00
if(!cmSystemTools::IsOff(def))
{
isTrue = false;
2001-05-01 19:16:20 +04:00
}
isValid = true;
2001-08-07 01:01:26 +04:00
}
if (args.size() == 2 && (args[0] == "COMMAND"))
{
if(!makefile->CommandExists(args[1].c_str()))
{
isTrue = false;
}
isValid = true;
}
2002-01-03 00:46:08 +03:00
if (args.size() == 2 && (args[0] == "EXISTS"))
{
if(!cmSystemTools::FileExists(args[1].c_str()))
2002-01-03 00:46:08 +03:00
{
isTrue = false;
2002-01-03 00:46:08 +03:00
}
isValid = true;
2002-01-03 00:46:08 +03:00
}
if (args.size() == 2 && (args[0] == "MATCHES"))
{
if(!cmSystemTools::FileExists(args[1].c_str()))
{
isTrue = false;
}
isValid = true;
}
2001-08-07 01:01:26 +04:00
if (args.size() == 3 && (args[1] == "AND"))
{
def = makefile->GetDefinition(args[0].c_str());
def2 = makefile->GetDefinition(args[2].c_str());
2001-08-09 22:58:47 +04:00
if(cmSystemTools::IsOff(def) || cmSystemTools::IsOff(def2))
2001-05-01 19:16:20 +04:00
{
isTrue = false;
2001-05-01 19:16:20 +04:00
}
isValid = true;
2001-04-20 01:39:03 +04:00
}
2001-08-07 01:01:26 +04:00
if (args.size() == 3 && (args[1] == "OR"))
2001-04-20 01:39:03 +04:00
{
def = makefile->GetDefinition(args[0].c_str());
def2 = makefile->GetDefinition(args[2].c_str());
2001-08-09 22:58:47 +04:00
if(cmSystemTools::IsOff(def) && cmSystemTools::IsOff(def2))
2001-05-01 19:16:20 +04:00
{
isTrue = false;
2001-05-01 19:16:20 +04:00
}
isValid = true;
2001-08-07 01:01:26 +04:00
}
if (args.size() == 3 && (args[1] == "MATCHES"))
{
def = cmIfCommand::GetVariableOrString(args[0].c_str(), makefile);
2001-08-07 01:01:26 +04:00
cmRegularExpression regEntry(args[2].c_str());
// check for black line or comment
if (!regEntry.find(def))
2001-05-01 19:16:20 +04:00
{
isTrue = false;
2001-08-07 01:01:26 +04:00
}
isValid = true;
2001-08-07 01:01:26 +04:00
}
2002-05-23 18:32:28 +04:00
if (args.size() == 3 && (args[1] == "LESS"))
{
def = cmIfCommand::GetVariableOrString(args[0].c_str(), makefile);
def2 = cmIfCommand::GetVariableOrString(args[2].c_str(), makefile);
2002-05-23 18:32:28 +04:00
if (!def)
{
def = args[0].c_str();
}
if (!def2)
{
def2 = args[2].c_str();
}
if(atof(def) >= atof(def2))
{
isTrue = false;
2002-05-23 18:32:28 +04:00
}
isValid = true;
2002-05-23 18:32:28 +04:00
}
if (args.size() == 3 && (args[1] == "GREATER"))
{
def = cmIfCommand::GetVariableOrString(args[0].c_str(), makefile);
def2 = cmIfCommand::GetVariableOrString(args[2].c_str(), makefile);
2002-05-23 18:32:28 +04:00
if(atof(def) <= atof(def2))
{
isTrue = false;
2002-05-23 18:32:28 +04:00
}
isValid = true;
2002-05-23 18:32:28 +04:00
}
if (args.size() == 3 && (args[1] == "STRLESS"))
{
def = cmIfCommand::GetVariableOrString(args[0].c_str(), makefile);
def2 = cmIfCommand::GetVariableOrString(args[2].c_str(), makefile);
2002-05-23 18:32:28 +04:00
if(strcmp(def,def2) >= 0)
{
isTrue = false;
2002-05-23 18:32:28 +04:00
}
isValid = true;
2002-05-23 18:32:28 +04:00
}
if (args.size() == 3 && (args[1] == "STRGREATER"))
{
def = cmIfCommand::GetVariableOrString(args[0].c_str(), makefile);
def2 = cmIfCommand::GetVariableOrString(args[2].c_str(), makefile);
2002-05-23 18:32:28 +04:00
if(strcmp(def,def2) <= 0)
{
isTrue = false;
2002-05-23 18:32:28 +04:00
}
isValid = true;
2002-05-23 18:32:28 +04:00
}
return isTrue;
2001-04-20 01:39:03 +04:00
}
const char* cmIfCommand::GetVariableOrString(const char* str,
const cmMakefile* mf)
{
const char* def = mf->GetDefinition(str);
if(!def)
{
def = str;
}
return def;
}