388 lines
9.6 KiB
C++
388 lines
9.6 KiB
C++
/*=========================================================================
|
|
|
|
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 "cmSetPropertyCommand.h"
|
|
#include "cmSetTargetPropertiesCommand.h"
|
|
#include "cmSetTestsPropertiesCommand.h"
|
|
#include "cmSetSourceFilesPropertiesCommand.h"
|
|
|
|
//----------------------------------------------------------------------------
|
|
cmSetPropertyCommand::cmSetPropertyCommand()
|
|
{
|
|
this->AppendMode = false;
|
|
this->Remove = true;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool cmSetPropertyCommand
|
|
::InitialPass(std::vector<std::string> const& args, cmExecutionStatus &)
|
|
{
|
|
if(args.size() < 2 )
|
|
{
|
|
this->SetError("called with incorrect number of arguments");
|
|
return false;
|
|
}
|
|
|
|
// Get the scope on which to set the property.
|
|
std::vector<std::string>::const_iterator arg = args.begin();
|
|
cmProperty::ScopeType scope;
|
|
if(*arg == "GLOBAL")
|
|
{
|
|
scope = cmProperty::GLOBAL;
|
|
}
|
|
else if(*arg == "DIRECTORY")
|
|
{
|
|
scope = cmProperty::DIRECTORY;
|
|
}
|
|
else if(*arg == "TARGET")
|
|
{
|
|
scope = cmProperty::TARGET;
|
|
}
|
|
else if(*arg == "SOURCE")
|
|
{
|
|
scope = cmProperty::SOURCE_FILE;
|
|
}
|
|
else if(*arg == "TEST")
|
|
{
|
|
scope = cmProperty::TEST;
|
|
}
|
|
else
|
|
{
|
|
cmOStringStream e;
|
|
e << "given invalid scope " << *arg << ". "
|
|
<< "Valid scopes are GLOBAL, DIRECTORY, TARGET, SOURCE, TEST.";
|
|
this->SetError(e.str().c_str());
|
|
return false;
|
|
}
|
|
|
|
// Parse the rest of the arguments up to the values.
|
|
enum Doing { DoingNone, DoingNames, DoingProperty, DoingValues };
|
|
Doing doing = DoingNames;
|
|
const char* sep = "";
|
|
for(++arg; arg != args.end(); ++arg)
|
|
{
|
|
if(*arg == "PROPERTY")
|
|
{
|
|
doing = DoingProperty;
|
|
}
|
|
else if(*arg == "APPEND")
|
|
{
|
|
doing = DoingNone;
|
|
this->AppendMode = true;
|
|
}
|
|
else if(doing == DoingNames)
|
|
{
|
|
this->Names.insert(*arg);
|
|
}
|
|
else if(doing == DoingProperty)
|
|
{
|
|
this->PropertyName = *arg;
|
|
doing = DoingValues;
|
|
}
|
|
else if(doing == DoingValues)
|
|
{
|
|
this->PropertyValue += sep;
|
|
sep = ";";
|
|
this->PropertyValue += *arg;
|
|
this->Remove = false;
|
|
}
|
|
else
|
|
{
|
|
cmOStringStream e;
|
|
e << "given invalid argument \"" << *arg << "\".";
|
|
this->SetError(e.str().c_str());
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// Make sure a property name was found.
|
|
if(this->PropertyName.empty())
|
|
{
|
|
this->SetError("not given a PROPERTY <name> argument.");
|
|
return false;
|
|
}
|
|
|
|
// Dispatch property setting.
|
|
switch(scope)
|
|
{
|
|
case cmProperty::GLOBAL: return this->HandleGlobalMode();
|
|
case cmProperty::DIRECTORY: return this->HandleDirectoryMode();
|
|
case cmProperty::TARGET: return this->HandleTargetMode();
|
|
case cmProperty::SOURCE_FILE: return this->HandleSourceMode();
|
|
case cmProperty::TEST: return this->HandleTestMode();
|
|
|
|
case cmProperty::VARIABLE:
|
|
case cmProperty::CACHED_VARIABLE:
|
|
break; // should never happen
|
|
}
|
|
return true;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool cmSetPropertyCommand::HandleGlobalMode()
|
|
{
|
|
if(!this->Names.empty())
|
|
{
|
|
this->SetError("given names for GLOBAL scope.");
|
|
return false;
|
|
}
|
|
|
|
// Set or append the property.
|
|
cmake* cm = this->Makefile->GetCMakeInstance();
|
|
const char* name = this->PropertyName.c_str();
|
|
const char *value = this->PropertyValue.c_str();
|
|
if (this->Remove)
|
|
{
|
|
value = 0;
|
|
}
|
|
if(this->AppendMode)
|
|
{
|
|
cm->AppendProperty(name, value);
|
|
}
|
|
else
|
|
{
|
|
cm->SetProperty(name, value);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool cmSetPropertyCommand::HandleDirectoryMode()
|
|
{
|
|
if(this->Names.size() > 1)
|
|
{
|
|
this->SetError("allows at most one name for DIRECTORY scope.");
|
|
return false;
|
|
}
|
|
|
|
// Default to the current directory.
|
|
cmMakefile* mf = this->Makefile;
|
|
|
|
// Lookup the directory if given.
|
|
if(!this->Names.empty())
|
|
{
|
|
// Construct the directory name. Interpret relative paths with
|
|
// respect to the current directory.
|
|
std::string dir = *this->Names.begin();
|
|
if(!cmSystemTools::FileIsFullPath(dir.c_str()))
|
|
{
|
|
dir = this->Makefile->GetCurrentDirectory();
|
|
dir += "/";
|
|
dir += *this->Names.begin();
|
|
}
|
|
|
|
// The local generators are associated with collapsed paths.
|
|
dir = cmSystemTools::CollapseFullPath(dir.c_str());
|
|
|
|
// Lookup the generator.
|
|
if(cmLocalGenerator* lg =
|
|
(this->Makefile->GetLocalGenerator()
|
|
->GetGlobalGenerator()->FindLocalGenerator(dir.c_str())))
|
|
{
|
|
// Use the makefile for the directory found.
|
|
mf = lg->GetMakefile();
|
|
}
|
|
else
|
|
{
|
|
// Could not find the directory.
|
|
this->SetError
|
|
("DIRECTORY scope provided but requested directory was not found. "
|
|
"This could be because the directory argument was invalid or, "
|
|
"it is valid but has not been processed yet.");
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// Set or append the property.
|
|
const char* name = this->PropertyName.c_str();
|
|
const char *value = this->PropertyValue.c_str();
|
|
if (this->Remove)
|
|
{
|
|
value = 0;
|
|
}
|
|
if(this->AppendMode)
|
|
{
|
|
mf->AppendProperty(name, value);
|
|
}
|
|
else
|
|
{
|
|
mf->SetProperty(name, value);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool cmSetPropertyCommand::HandleTargetMode()
|
|
{
|
|
for(std::set<cmStdString>::const_iterator ni = this->Names.begin();
|
|
ni != this->Names.end(); ++ni)
|
|
{
|
|
if(cmTarget* target = this->Makefile->FindTargetToUse(ni->c_str()))
|
|
{
|
|
// Handle the current target.
|
|
if(!this->HandleTarget(target))
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
cmOStringStream e;
|
|
e << "could not find TARGET " << *ni
|
|
<< ". Perhaps it has not yet been created.";
|
|
this->SetError(e.str().c_str());
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool cmSetPropertyCommand::HandleTarget(cmTarget* target)
|
|
{
|
|
// Set or append the property.
|
|
const char* name = this->PropertyName.c_str();
|
|
const char *value = this->PropertyValue.c_str();
|
|
if (this->Remove)
|
|
{
|
|
value = 0;
|
|
}
|
|
if(this->AppendMode)
|
|
{
|
|
target->AppendProperty(name, value);
|
|
}
|
|
else
|
|
{
|
|
target->SetProperty(name, value);
|
|
}
|
|
|
|
// Check the resulting value.
|
|
target->CheckProperty(name, this->Makefile);
|
|
|
|
return true;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool cmSetPropertyCommand::HandleSourceMode()
|
|
{
|
|
for(std::set<cmStdString>::const_iterator ni = this->Names.begin();
|
|
ni != this->Names.end(); ++ni)
|
|
{
|
|
// Get the source file.
|
|
if(cmSourceFile* sf = this->Makefile->GetOrCreateSource(ni->c_str()))
|
|
{
|
|
if(!this->HandleSource(sf))
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
cmOStringStream e;
|
|
e << "given SOURCE name that could not be found or created: " << *ni;
|
|
this->SetError(e.str().c_str());
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool cmSetPropertyCommand::HandleSource(cmSourceFile* sf)
|
|
{
|
|
// Set or append the property.
|
|
const char* name = this->PropertyName.c_str();
|
|
const char *value = this->PropertyValue.c_str();
|
|
if (this->Remove)
|
|
{
|
|
value = 0;
|
|
}
|
|
|
|
if(this->AppendMode)
|
|
{
|
|
sf->AppendProperty(name, value);
|
|
}
|
|
else
|
|
{
|
|
sf->SetProperty(name, value);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool cmSetPropertyCommand::HandleTestMode()
|
|
{
|
|
// Loop over all tests looking for matching names.
|
|
std::vector<cmTest*> const& tests = *this->Makefile->GetTests();
|
|
for(std::vector<cmTest*>::const_iterator ti = tests.begin();
|
|
ti != tests.end(); ++ti)
|
|
{
|
|
cmTest* test = *ti;
|
|
std::set<cmStdString>::iterator ni =
|
|
this->Names.find(test->GetName());
|
|
if(ni != this->Names.end())
|
|
{
|
|
if(this->HandleTest(test))
|
|
{
|
|
this->Names.erase(ni);
|
|
}
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Names that are still left were not found.
|
|
if(!this->Names.empty())
|
|
{
|
|
cmOStringStream e;
|
|
e << "given TEST names that do not exist:\n";
|
|
for(std::set<cmStdString>::const_iterator ni = this->Names.begin();
|
|
ni != this->Names.end(); ++ni)
|
|
{
|
|
e << " " << *ni << "\n";
|
|
}
|
|
this->SetError(e.str().c_str());
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool cmSetPropertyCommand::HandleTest(cmTest* test)
|
|
{
|
|
// Set or append the property.
|
|
const char* name = this->PropertyName.c_str();
|
|
const char *value = this->PropertyValue.c_str();
|
|
if (this->Remove)
|
|
{
|
|
value = 0;
|
|
}
|
|
if(this->AppendMode)
|
|
{
|
|
test->AppendProperty(name, value);
|
|
}
|
|
else
|
|
{
|
|
test->SetProperty(name, value);
|
|
}
|
|
|
|
return true;
|
|
}
|