CMake/Source/cmParseArgumentsCommand.cxx

201 lines
6.4 KiB
C++
Raw Normal View History

/*============================================================================
CMake - Cross Platform Makefile Generator
Copyright 2015 Matthias Maennich <matthias@maennich.net>
Copyright 2010 Alexander Neundorf <neundorf@kde.org>
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.
============================================================================*/
#include "cmParseArgumentsCommand.h"
#include "cmAlgorithms.h"
//----------------------------------------------------------------------------
bool cmParseArgumentsCommand
::InitialPass(std::vector<std::string> const& args, cmExecutionStatus &)
{
// cmake_parse_arguments(prefix options single multi <ARGN>)
// 1 2 3 4
if (args.size() < 4)
{
this->SetError("must be called with at least 4 arguments.");
return false;
}
std::vector<std::string>::const_iterator argIter = args.begin(),
argEnd = args.end();
// the first argument is the prefix
const std::string prefix = (*argIter++) + "_";
// define the result maps holding key/value pairs for
// options, single values and multi values
typedef std::map<std::string, bool> options_map;
typedef std::map<std::string, std::string> single_map;
typedef std::map<std::string, std::vector<std::string> > multi_map;
options_map options;
single_map single;
multi_map multi;
// anything else is put into a vector of unparsed strings
std::vector<std::string> unparsed;
// remember already defined keywords
std::set<std::string> used_keywords;
const std::string dup_warning = "keyword defined more than once: ";
// the second argument is a (cmake) list of options without argument
std::vector<std::string> list;
cmSystemTools::ExpandListArgument(*argIter++, list);
for (std::vector<std::string>::const_iterator iter = list.begin(),
end = list.end();
iter != end; ++iter)
{
if (!used_keywords.insert(*iter).second)
{
this->GetMakefile()->IssueMessage(cmake::WARNING, dup_warning + *iter);
}
options[*iter]; // default initialize
}
// the third argument is a (cmake) list of single argument options
list.clear();
cmSystemTools::ExpandListArgument(*argIter++, list);
for (std::vector<std::string>::const_iterator iter = list.begin(),
end = list.end();
iter != end; ++iter)
{
if (!used_keywords.insert(*iter).second)
{
this->GetMakefile()->IssueMessage(cmake::WARNING, dup_warning + *iter);
}
single[*iter]; // default initialize
}
// the fourth argument is a (cmake) list of multi argument options
list.clear();
cmSystemTools::ExpandListArgument(*argIter++, list);
for (std::vector<std::string>::const_iterator iter = list.begin(),
end = list.end();
iter != end; ++iter)
{
if (!used_keywords.insert(*iter).second)
{
this->GetMakefile()->IssueMessage(cmake::WARNING, dup_warning + *iter);
}
multi[*iter]; // default initialize
}
enum insideValues
{
NONE,
SINGLE,
MULTI
} insideValues = NONE;
std::string currentArgName;
// Flatten ;-lists in the arguments into a single list as was done
// by the original function(CMAKE_PARSE_ARGUMENTS).
list.clear();
for(; argIter != argEnd; ++argIter)
{
cmSystemTools::ExpandListArgument(*argIter, list);
}
// iterate over the arguments list and fill in the values where applicable
for (argIter = list.begin(), argEnd = list.end();
argIter != argEnd; ++argIter)
{
const options_map::iterator optIter = options.find(*argIter);
if (optIter != options.end())
{
insideValues = NONE;
optIter->second = true;
continue;
}
const single_map::iterator singleIter = single.find(*argIter);
if (singleIter != single.end())
{
insideValues = SINGLE;
currentArgName = *argIter;
continue;
}
const multi_map::iterator multiIter = multi.find(*argIter);
if (multiIter != multi.end())
{
insideValues = MULTI;
currentArgName = *argIter;
continue;
}
switch(insideValues)
{
case SINGLE:
single[currentArgName] = *argIter;
insideValues = NONE;
break;
case MULTI:
multi[currentArgName].push_back(*argIter);
break;
default:
unparsed.push_back(*argIter);
break;
}
}
// now iterate over the collected values and update their definition
// within the current scope. undefine if necessary.
for (options_map::const_iterator iter = options.begin(), end = options.end();
iter != end; ++iter)
{
this->Makefile->AddDefinition(prefix + iter->first,
iter->second? "TRUE": "FALSE");
}
for (single_map::const_iterator iter = single.begin(), end = single.end();
iter != end; ++iter)
{
if (!iter->second.empty())
{
this->Makefile->AddDefinition(prefix + iter->first,
iter->second.c_str());
}
else
{
this->Makefile->RemoveDefinition(prefix + iter->first);
}
}
for (multi_map::const_iterator iter = multi.begin(), end = multi.end();
iter != end; ++iter)
{
if (!iter->second.empty())
{
this->Makefile->AddDefinition(prefix + iter->first,
cmJoin(cmMakeRange(iter->second), ";")
.c_str());
}
else
{
this->Makefile->RemoveDefinition(prefix + iter->first);
}
}
if (!unparsed.empty())
{
this->Makefile->AddDefinition(prefix + "UNPARSED_ARGUMENTS",
cmJoin(cmMakeRange(unparsed), ";").c_str());
}
else
{
this->Makefile->RemoveDefinition(prefix + "UNPARSED_ARGUMENTS");
}
return true;
}