mirror of
https://github.com/reactos/CMake.git
synced 2024-12-15 07:41:15 +00:00
96afb12087
This converts the CMake license to a pure 3-clause OSI-approved BSD License. We drop the previous license clause requiring modified versions to be plainly marked. We also update the CMake copyright to cover the full development time range.
935 lines
26 KiB
C++
935 lines
26 KiB
C++
/*============================================================================
|
|
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.
|
|
============================================================================*/
|
|
/*
|
|
this file contains the implementation of the C API to CMake. Generally
|
|
these routines just manipulate arguments and then call the associated
|
|
methods on the CMake classes. */
|
|
|
|
#include "cmMakefile.h"
|
|
#include "cmCPluginAPI.h"
|
|
#include "cmVersion.h"
|
|
|
|
#include "cmSourceFile.h"
|
|
|
|
#include <stdlib.h>
|
|
|
|
#ifdef __QNX__
|
|
# include <malloc.h> /* for malloc/free on QNX */
|
|
#endif
|
|
|
|
extern "C"
|
|
{
|
|
|
|
void CCONV *cmGetClientData(void *info)
|
|
{
|
|
return ((cmLoadedCommandInfo *)info)->ClientData;
|
|
}
|
|
|
|
void CCONV cmSetClientData(void *info, void *cd)
|
|
{
|
|
((cmLoadedCommandInfo *)info)->ClientData = cd;
|
|
}
|
|
|
|
void CCONV cmSetError(void *info, const char *err)
|
|
{
|
|
if (((cmLoadedCommandInfo *)info)->Error)
|
|
{
|
|
free(((cmLoadedCommandInfo *)info)->Error);
|
|
}
|
|
((cmLoadedCommandInfo *)info)->Error = strdup(err);
|
|
}
|
|
|
|
unsigned int CCONV cmGetCacheMajorVersion(void *arg)
|
|
{
|
|
cmMakefile *mf = static_cast<cmMakefile *>(arg);
|
|
return mf->GetCacheMajorVersion();
|
|
}
|
|
unsigned int CCONV cmGetCacheMinorVersion(void *arg)
|
|
{
|
|
cmMakefile *mf = static_cast<cmMakefile *>(arg);
|
|
return mf->GetCacheMinorVersion();
|
|
}
|
|
|
|
unsigned int CCONV cmGetMajorVersion(void *)
|
|
{
|
|
return cmVersion::GetMajorVersion();
|
|
}
|
|
|
|
unsigned int CCONV cmGetMinorVersion(void *)
|
|
{
|
|
return cmVersion::GetMinorVersion();
|
|
}
|
|
|
|
void CCONV cmAddDefinition(void *arg, const char* name, const char* value)
|
|
{
|
|
cmMakefile *mf = static_cast<cmMakefile *>(arg);
|
|
mf->AddDefinition(name,value);
|
|
}
|
|
|
|
/* Add a definition to this makefile and the global cmake cache. */
|
|
void CCONV cmAddCacheDefinition(void *arg, const char* name,
|
|
const char* value, const char* doc, int type)
|
|
{
|
|
cmMakefile *mf = static_cast<cmMakefile *>(arg);
|
|
|
|
switch (type)
|
|
{
|
|
case CM_CACHE_BOOL:
|
|
mf->AddCacheDefinition(name,value,doc,
|
|
cmCacheManager::BOOL);
|
|
break;
|
|
case CM_CACHE_PATH:
|
|
mf->AddCacheDefinition(name,value,doc,
|
|
cmCacheManager::PATH);
|
|
break;
|
|
case CM_CACHE_FILEPATH:
|
|
mf->AddCacheDefinition(name,value,doc,
|
|
cmCacheManager::FILEPATH);
|
|
break;
|
|
case CM_CACHE_STRING:
|
|
mf->AddCacheDefinition(name,value,doc,
|
|
cmCacheManager::STRING);
|
|
break;
|
|
case CM_CACHE_INTERNAL:
|
|
mf->AddCacheDefinition(name,value,doc,
|
|
cmCacheManager::INTERNAL);
|
|
break;
|
|
case CM_CACHE_STATIC:
|
|
mf->AddCacheDefinition(name,value,doc,
|
|
cmCacheManager::STATIC);
|
|
break;
|
|
}
|
|
}
|
|
|
|
const char* CCONV cmGetProjectName(void *arg)
|
|
{
|
|
cmMakefile *mf = static_cast<cmMakefile *>(arg);
|
|
return mf->GetProjectName();
|
|
}
|
|
|
|
const char* CCONV cmGetHomeDirectory(void *arg)
|
|
{
|
|
cmMakefile *mf = static_cast<cmMakefile *>(arg);
|
|
return mf->GetHomeDirectory();
|
|
}
|
|
const char* CCONV cmGetHomeOutputDirectory(void *arg)
|
|
{
|
|
cmMakefile *mf = static_cast<cmMakefile *>(arg);
|
|
return mf->GetHomeOutputDirectory();
|
|
}
|
|
const char* CCONV cmGetStartDirectory(void *arg)
|
|
{
|
|
cmMakefile *mf = static_cast<cmMakefile *>(arg);
|
|
return mf->GetStartDirectory();
|
|
}
|
|
const char* CCONV cmGetStartOutputDirectory(void *arg)
|
|
{
|
|
cmMakefile *mf = static_cast<cmMakefile *>(arg);
|
|
return mf->GetStartOutputDirectory();
|
|
}
|
|
const char* CCONV cmGetCurrentDirectory(void *arg)
|
|
{
|
|
cmMakefile *mf = static_cast<cmMakefile *>(arg);
|
|
return mf->GetCurrentDirectory();
|
|
}
|
|
const char* CCONV cmGetCurrentOutputDirectory(void *arg)
|
|
{
|
|
cmMakefile *mf = static_cast<cmMakefile *>(arg);
|
|
return mf->GetCurrentOutputDirectory();
|
|
}
|
|
const char* CCONV cmGetDefinition(void *arg,const char*def)
|
|
{
|
|
cmMakefile *mf = static_cast<cmMakefile *>(arg);
|
|
return mf->GetDefinition(def);
|
|
}
|
|
|
|
int CCONV cmIsOn(void *arg, const char* name)
|
|
{
|
|
cmMakefile *mf = static_cast<cmMakefile *>(arg);
|
|
return static_cast<int>(mf->IsOn(name));
|
|
}
|
|
|
|
/** Check if a command exists. */
|
|
int CCONV cmCommandExists(void *arg, const char* name)
|
|
{
|
|
cmMakefile *mf = static_cast<cmMakefile *>(arg);
|
|
return static_cast<int>(mf->CommandExists(name));
|
|
}
|
|
|
|
void CCONV cmAddDefineFlag(void *arg, const char* definition)
|
|
{
|
|
cmMakefile *mf = static_cast<cmMakefile *>(arg);
|
|
mf->AddDefineFlag(definition);
|
|
}
|
|
|
|
void CCONV cmAddLinkDirectoryForTarget(void *arg, const char *tgt,
|
|
const char* d)
|
|
{
|
|
cmMakefile *mf = static_cast<cmMakefile *>(arg);
|
|
mf->AddLinkDirectoryForTarget(tgt,d);
|
|
}
|
|
|
|
|
|
void CCONV cmAddExecutable(void *arg, const char *exename,
|
|
int numSrcs, const char **srcs, int win32)
|
|
{
|
|
cmMakefile *mf = static_cast<cmMakefile *>(arg);
|
|
std::vector<std::string> srcs2;
|
|
int i;
|
|
for (i = 0; i < numSrcs; ++i)
|
|
{
|
|
srcs2.push_back(srcs[i]);
|
|
}
|
|
cmTarget* tg = mf->AddExecutable(exename, srcs2);
|
|
if ( win32 )
|
|
{
|
|
tg->SetProperty("WIN32_EXECUTABLE", "ON");
|
|
}
|
|
}
|
|
|
|
void CCONV cmAddUtilityCommand(void *arg, const char* utilityName,
|
|
const char* command,
|
|
const char* arguments,
|
|
int all,
|
|
int numDepends,
|
|
const char **depends,
|
|
int,
|
|
const char **)
|
|
{
|
|
// Get the makefile instance. Perform an extra variable expansion
|
|
// now because the API caller expects it.
|
|
cmMakefile* mf = static_cast<cmMakefile*>(arg);
|
|
|
|
// Construct the command line for the command.
|
|
cmCustomCommandLine commandLine;
|
|
std::string expand = command;
|
|
commandLine.push_back(mf->ExpandVariablesInString(expand));
|
|
if(arguments && arguments[0])
|
|
{
|
|
// TODO: Parse arguments!
|
|
expand = arguments;
|
|
commandLine.push_back(mf->ExpandVariablesInString(expand));
|
|
}
|
|
cmCustomCommandLines commandLines;
|
|
commandLines.push_back(commandLine);
|
|
|
|
// Accumulate the list of dependencies.
|
|
std::vector<std::string> depends2;
|
|
for(int i = 0; i < numDepends; ++i)
|
|
{
|
|
expand = depends[i];
|
|
depends2.push_back(mf->ExpandVariablesInString(expand));
|
|
}
|
|
|
|
// Pass the call to the makefile instance.
|
|
mf->AddUtilityCommand(utilityName, (all ? false : true),
|
|
0, depends2, commandLines);
|
|
}
|
|
void CCONV cmAddCustomCommand(void *arg, const char* source,
|
|
const char* command,
|
|
int numArgs, const char **args,
|
|
int numDepends, const char **depends,
|
|
int numOutputs, const char **outputs,
|
|
const char *target)
|
|
{
|
|
// Get the makefile instance. Perform an extra variable expansion
|
|
// now because the API caller expects it.
|
|
cmMakefile* mf = static_cast<cmMakefile*>(arg);
|
|
|
|
// Construct the command line for the command.
|
|
cmCustomCommandLine commandLine;
|
|
std::string expand = command;
|
|
commandLine.push_back(mf->ExpandVariablesInString(expand));
|
|
for(int i=0; i < numArgs; ++i)
|
|
{
|
|
expand = args[i];
|
|
commandLine.push_back(mf->ExpandVariablesInString(expand));
|
|
}
|
|
cmCustomCommandLines commandLines;
|
|
commandLines.push_back(commandLine);
|
|
|
|
// Accumulate the list of dependencies.
|
|
std::vector<std::string> depends2;
|
|
for(int i = 0; i < numDepends; ++i)
|
|
{
|
|
expand = depends[i];
|
|
depends2.push_back(mf->ExpandVariablesInString(expand));
|
|
}
|
|
|
|
// Accumulate the list of outputs.
|
|
std::vector<std::string> outputs2;
|
|
for(int i = 0; i < numOutputs; ++i)
|
|
{
|
|
expand = outputs[i];
|
|
outputs2.push_back(mf->ExpandVariablesInString(expand));
|
|
}
|
|
|
|
// Pass the call to the makefile instance.
|
|
const char* no_comment = 0;
|
|
mf->AddCustomCommandOldStyle(target, outputs2, depends2, source,
|
|
commandLines, no_comment);
|
|
}
|
|
|
|
void CCONV cmAddCustomCommandToOutput(void *arg, const char* output,
|
|
const char* command,
|
|
int numArgs, const char **args,
|
|
const char* main_dependency,
|
|
int numDepends, const char **depends)
|
|
{
|
|
// Get the makefile instance. Perform an extra variable expansion
|
|
// now because the API caller expects it.
|
|
cmMakefile* mf = static_cast<cmMakefile*>(arg);
|
|
|
|
// Construct the command line for the command.
|
|
cmCustomCommandLine commandLine;
|
|
std::string expand = command;
|
|
commandLine.push_back(mf->ExpandVariablesInString(expand));
|
|
for(int i=0; i < numArgs; ++i)
|
|
{
|
|
expand = args[i];
|
|
commandLine.push_back(mf->ExpandVariablesInString(expand));
|
|
}
|
|
cmCustomCommandLines commandLines;
|
|
commandLines.push_back(commandLine);
|
|
|
|
// Accumulate the list of dependencies.
|
|
std::vector<std::string> depends2;
|
|
for(int i = 0; i < numDepends; ++i)
|
|
{
|
|
expand = depends[i];
|
|
depends2.push_back(mf->ExpandVariablesInString(expand));
|
|
}
|
|
|
|
// Pass the call to the makefile instance.
|
|
const char* no_comment = 0;
|
|
const char* no_working_dir = 0;
|
|
mf->AddCustomCommandToOutput(output, depends2, main_dependency,
|
|
commandLines, no_comment, no_working_dir);
|
|
}
|
|
|
|
void CCONV cmAddCustomCommandToTarget(void *arg, const char* target,
|
|
const char* command,
|
|
int numArgs, const char **args,
|
|
int commandType)
|
|
{
|
|
// Get the makefile instance.
|
|
cmMakefile* mf = static_cast<cmMakefile*>(arg);
|
|
|
|
// Construct the command line for the command. Perform an extra
|
|
// variable expansion now because the API caller expects it.
|
|
cmCustomCommandLine commandLine;
|
|
std::string expand = command;
|
|
commandLine.push_back(mf->ExpandVariablesInString(expand));
|
|
for(int i=0; i < numArgs; ++i)
|
|
{
|
|
expand = args[i];
|
|
commandLine.push_back(mf->ExpandVariablesInString(expand));
|
|
}
|
|
cmCustomCommandLines commandLines;
|
|
commandLines.push_back(commandLine);
|
|
|
|
// Select the command type.
|
|
cmTarget::CustomCommandType cctype = cmTarget::POST_BUILD;
|
|
switch (commandType)
|
|
{
|
|
case CM_PRE_BUILD:
|
|
cctype = cmTarget::PRE_BUILD;
|
|
break;
|
|
case CM_PRE_LINK:
|
|
cctype = cmTarget::PRE_LINK;
|
|
break;
|
|
case CM_POST_BUILD:
|
|
cctype = cmTarget::POST_BUILD;
|
|
break;
|
|
}
|
|
|
|
// Pass the call to the makefile instance.
|
|
std::vector<std::string> no_depends;
|
|
const char* no_comment = 0;
|
|
const char* no_working_dir = 0;
|
|
mf->AddCustomCommandToTarget(target, no_depends, commandLines,
|
|
cctype, no_comment, no_working_dir);
|
|
}
|
|
|
|
void CCONV cmAddLinkLibraryForTarget(void *arg, const char *tgt,
|
|
const char*value, int libtype)
|
|
{
|
|
cmMakefile *mf = static_cast<cmMakefile *>(arg);
|
|
|
|
switch (libtype)
|
|
{
|
|
case CM_LIBRARY_GENERAL:
|
|
mf->AddLinkLibraryForTarget(tgt,value, cmTarget::GENERAL);
|
|
break;
|
|
case CM_LIBRARY_DEBUG:
|
|
mf->AddLinkLibraryForTarget(tgt,value, cmTarget::DEBUG);
|
|
break;
|
|
case CM_LIBRARY_OPTIMIZED:
|
|
mf->AddLinkLibraryForTarget(tgt,value, cmTarget::OPTIMIZED);
|
|
break;
|
|
}
|
|
}
|
|
|
|
void CCONV cmAddLibrary(void *arg, const char *libname, int shared,
|
|
int numSrcs, const char **srcs)
|
|
{
|
|
cmMakefile *mf = static_cast<cmMakefile *>(arg);
|
|
std::vector<std::string> srcs2;
|
|
int i;
|
|
for (i = 0; i < numSrcs; ++i)
|
|
{
|
|
srcs2.push_back(srcs[i]);
|
|
}
|
|
mf->AddLibrary(libname,
|
|
(shared? cmTarget::SHARED_LIBRARY : cmTarget::STATIC_LIBRARY),
|
|
srcs2);
|
|
}
|
|
|
|
char CCONV *cmExpandVariablesInString(void *arg, const char *source,
|
|
int escapeQuotes, int atOnly)
|
|
{
|
|
cmMakefile *mf = static_cast<cmMakefile *>(arg);
|
|
std::string barf = source;
|
|
std::string result =
|
|
mf->ExpandVariablesInString(barf,
|
|
(escapeQuotes ? true : false),
|
|
(atOnly ? true : false));
|
|
char *res = static_cast<char *>(malloc(result.size() + 1));
|
|
if (result.size())
|
|
{
|
|
strcpy(res,result.c_str());
|
|
}
|
|
res[result.size()] = '\0';
|
|
return res;
|
|
}
|
|
|
|
|
|
int CCONV cmExecuteCommand(void *arg, const char *name,
|
|
int numArgs, const char **args)
|
|
{
|
|
cmMakefile *mf = static_cast<cmMakefile *>(arg);
|
|
cmListFileFunction lff;
|
|
lff.Name = name;
|
|
for(int i = 0; i < numArgs; ++i)
|
|
{
|
|
// Assume all arguments are quoted.
|
|
lff.Arguments.push_back(cmListFileArgument(args[i], true,
|
|
"[CMake-Plugin]", 0));
|
|
}
|
|
cmExecutionStatus status;
|
|
return mf->ExecuteCommand(lff,status);
|
|
}
|
|
|
|
void CCONV cmExpandSourceListArguments(void *arg,
|
|
int numArgs,
|
|
const char **args,
|
|
int *resArgc,
|
|
char ***resArgv,
|
|
unsigned int startArgumentIndex)
|
|
{
|
|
cmMakefile *mf = static_cast<cmMakefile *>(arg);
|
|
std::vector<std::string> result;
|
|
std::vector<std::string> args2;
|
|
int i;
|
|
for (i = 0; i < numArgs; ++i)
|
|
{
|
|
args2.push_back(args[i]);
|
|
}
|
|
mf->ExpandSourceListArguments(args2, result, startArgumentIndex);
|
|
int resargc = static_cast<int>(result.size());
|
|
char **resargv = 0;
|
|
if (resargc)
|
|
{
|
|
resargv = (char **)malloc(resargc*sizeof(char *));
|
|
}
|
|
for (i = 0; i < resargc; ++i)
|
|
{
|
|
resargv[i] = strdup(result[i].c_str());
|
|
}
|
|
*resArgc = resargc;
|
|
*resArgv = resargv;
|
|
}
|
|
|
|
void CCONV cmFreeArguments(int argc, char **argv)
|
|
{
|
|
int i;
|
|
for (i = 0; i < argc; ++i)
|
|
{
|
|
free(argv[i]);
|
|
}
|
|
if (argv)
|
|
{
|
|
free(argv);
|
|
}
|
|
}
|
|
|
|
int CCONV cmGetTotalArgumentSize(int argc, char **argv)
|
|
{
|
|
int i;
|
|
int result = 0;
|
|
for (i = 0; i < argc; ++i)
|
|
{
|
|
if (argv[i])
|
|
{
|
|
result = result + static_cast<int>(strlen(argv[i]));
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
// Source file proxy object to support the old cmSourceFile/cmMakefile
|
|
// API for source files.
|
|
struct cmCPluginAPISourceFile
|
|
{
|
|
cmCPluginAPISourceFile(): RealSourceFile(0) {}
|
|
cmSourceFile* RealSourceFile;
|
|
std::string SourceName;
|
|
std::string SourceExtension;
|
|
std::string FullPath;
|
|
std::vector<std::string> Depends;
|
|
cmPropertyMap Properties;
|
|
};
|
|
|
|
// Keep a map from real cmSourceFile instances stored in a makefile to
|
|
// the CPluginAPI proxy source file.
|
|
class cmCPluginAPISourceFileMap:
|
|
public std::map<cmSourceFile*, cmCPluginAPISourceFile*>
|
|
{
|
|
public:
|
|
typedef std::map<cmSourceFile*, cmCPluginAPISourceFile*> derived;
|
|
typedef derived::iterator iterator;
|
|
typedef derived::value_type value_type;
|
|
~cmCPluginAPISourceFileMap()
|
|
{
|
|
for(iterator i=this->begin(); i != this->end(); ++i)
|
|
{
|
|
delete i->second;
|
|
}
|
|
}
|
|
};
|
|
cmCPluginAPISourceFileMap cmCPluginAPISourceFiles;
|
|
|
|
void * CCONV cmCreateSourceFile()
|
|
{
|
|
return (void*)new cmCPluginAPISourceFile;
|
|
}
|
|
|
|
void * CCONV cmCreateNewSourceFile(void *arg)
|
|
{
|
|
cmMakefile *mf = static_cast<cmMakefile *>(arg);
|
|
cmCPluginAPISourceFile *sf = new cmCPluginAPISourceFile;
|
|
sf->Properties.SetCMakeInstance(mf->GetCMakeInstance());
|
|
return (void*)sf;
|
|
}
|
|
|
|
void CCONV cmDestroySourceFile(void *arg)
|
|
{
|
|
cmCPluginAPISourceFile* sf = static_cast<cmCPluginAPISourceFile*>(arg);
|
|
// Only delete if it was created by cmCreateSourceFile or
|
|
// cmCreateNewSourceFile and is therefore not in the map.
|
|
if(!sf->RealSourceFile)
|
|
{
|
|
delete sf;
|
|
}
|
|
}
|
|
|
|
void CCONV *cmGetSource(void *arg, const char *name)
|
|
{
|
|
cmMakefile *mf = static_cast<cmMakefile *>(arg);
|
|
if(cmSourceFile* rsf = mf->GetSource(name))
|
|
{
|
|
// Lookup the proxy source file object for this source.
|
|
cmCPluginAPISourceFileMap::iterator i = cmCPluginAPISourceFiles.find(rsf);
|
|
if(i == cmCPluginAPISourceFiles.end())
|
|
{
|
|
// Create a proxy source file object for this source.
|
|
cmCPluginAPISourceFile* sf = new cmCPluginAPISourceFile;
|
|
sf->RealSourceFile = rsf;
|
|
sf->FullPath = rsf->GetFullPath();
|
|
sf->SourceName =
|
|
cmSystemTools::GetFilenameWithoutLastExtension(sf->FullPath.c_str());
|
|
sf->SourceExtension =
|
|
cmSystemTools::GetFilenameLastExtension(sf->FullPath.c_str());
|
|
|
|
// Store the proxy in the map so it can be re-used and deleted later.
|
|
cmCPluginAPISourceFileMap::value_type entry(rsf, sf);
|
|
i = cmCPluginAPISourceFiles.insert(entry).first;
|
|
}
|
|
return (void *)i->second;
|
|
}
|
|
else
|
|
{
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
void * CCONV cmAddSource(void *arg, void *arg2)
|
|
{
|
|
cmMakefile *mf = static_cast<cmMakefile *>(arg);
|
|
cmCPluginAPISourceFile* osf = static_cast<cmCPluginAPISourceFile*>(arg2);
|
|
if(osf->FullPath.empty())
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
// Create the real cmSourceFile instance and copy over saved information.
|
|
cmSourceFile* rsf = mf->GetOrCreateSource(osf->FullPath.c_str());
|
|
rsf->GetProperties() = osf->Properties;
|
|
for(std::vector<std::string>::iterator i = osf->Depends.begin();
|
|
i != osf->Depends.end(); ++i)
|
|
{
|
|
rsf->AddDepend(i->c_str());
|
|
}
|
|
|
|
// Create the proxy for the real source file.
|
|
cmCPluginAPISourceFile* sf = new cmCPluginAPISourceFile;
|
|
sf->RealSourceFile = rsf;
|
|
sf->FullPath = osf->FullPath;
|
|
sf->SourceName = osf->SourceName;
|
|
sf->SourceExtension = osf->SourceExtension;
|
|
|
|
// Store the proxy in the map so it can be re-used and deleted later.
|
|
cmCPluginAPISourceFiles[rsf] = sf;
|
|
return (void *)sf;
|
|
}
|
|
|
|
const char * CCONV cmSourceFileGetSourceName(void *arg)
|
|
{
|
|
cmCPluginAPISourceFile* sf = static_cast<cmCPluginAPISourceFile*>(arg);
|
|
return sf->SourceName.c_str();
|
|
}
|
|
|
|
const char * CCONV cmSourceFileGetFullPath(void *arg)
|
|
{
|
|
cmCPluginAPISourceFile* sf = static_cast<cmCPluginAPISourceFile*>(arg);
|
|
return sf->FullPath.c_str();
|
|
}
|
|
|
|
const char * CCONV cmSourceFileGetProperty(void *arg,const char *prop)
|
|
{
|
|
cmCPluginAPISourceFile* sf = static_cast<cmCPluginAPISourceFile*>(arg);
|
|
if(cmSourceFile* rsf = sf->RealSourceFile)
|
|
{
|
|
return rsf->GetProperty(prop);
|
|
}
|
|
else
|
|
{
|
|
if(!strcmp(prop,"LOCATION"))
|
|
{
|
|
return sf->FullPath.c_str();
|
|
}
|
|
bool chain = false;
|
|
// Ignore chain because old code will not expect it and it is a
|
|
// pain to implement here anyway.
|
|
return sf->Properties.GetPropertyValue(prop, cmProperty::SOURCE_FILE,
|
|
chain);
|
|
}
|
|
}
|
|
|
|
int CCONV cmSourceFileGetPropertyAsBool(void *arg,const char *prop)
|
|
{
|
|
cmCPluginAPISourceFile* sf = static_cast<cmCPluginAPISourceFile*>(arg);
|
|
if(cmSourceFile* rsf = sf->RealSourceFile)
|
|
{
|
|
return rsf->GetPropertyAsBool(prop) ? 1:0;
|
|
}
|
|
else
|
|
{
|
|
return cmSystemTools::IsOn(cmSourceFileGetProperty(arg, prop))? 1:0;
|
|
}
|
|
}
|
|
|
|
void CCONV cmSourceFileSetProperty(void *arg,const char *prop,
|
|
const char *value)
|
|
{
|
|
cmCPluginAPISourceFile* sf = static_cast<cmCPluginAPISourceFile*>(arg);
|
|
if(cmSourceFile* rsf = sf->RealSourceFile)
|
|
{
|
|
rsf->SetProperty(prop, value);
|
|
}
|
|
else if(prop)
|
|
{
|
|
if(!value) { value = "NOTFOUND"; }
|
|
sf->Properties.SetProperty(prop, value, cmProperty::SOURCE_FILE);
|
|
}
|
|
}
|
|
|
|
void CCONV cmSourceFileAddDepend(void *arg, const char *depend)
|
|
{
|
|
cmCPluginAPISourceFile* sf = static_cast<cmCPluginAPISourceFile*>(arg);
|
|
if(cmSourceFile* rsf = sf->RealSourceFile)
|
|
{
|
|
rsf->AddDepend(depend);
|
|
}
|
|
else
|
|
{
|
|
sf->Depends.push_back(depend);
|
|
}
|
|
}
|
|
|
|
void CCONV cmSourceFileSetName(void *arg, const char* name, const char* dir,
|
|
int numSourceExtensions,
|
|
const char **sourceExtensions,
|
|
int numHeaderExtensions,
|
|
const char **headerExtensions)
|
|
{
|
|
cmCPluginAPISourceFile* sf = static_cast<cmCPluginAPISourceFile*>(arg);
|
|
if(sf->RealSourceFile)
|
|
{
|
|
// SetName is allowed only on temporary source files created by
|
|
// the command for building and passing to AddSource.
|
|
return;
|
|
}
|
|
std::vector<std::string> sourceExts;
|
|
std::vector<std::string> headerExts;
|
|
int i;
|
|
for (i = 0; i < numSourceExtensions; ++i)
|
|
{
|
|
sourceExts.push_back(sourceExtensions[i]);
|
|
}
|
|
for (i = 0; i < numHeaderExtensions; ++i)
|
|
{
|
|
headerExts.push_back(headerExtensions[i]);
|
|
}
|
|
|
|
// Save the original name given.
|
|
sf->SourceName = name;
|
|
|
|
// Convert the name to a full path in case the given name is a
|
|
// relative path.
|
|
std::string pathname = cmSystemTools::CollapseFullPath(name, dir);
|
|
|
|
// First try and see whether the listed file can be found
|
|
// as is without extensions added on.
|
|
std::string hname = pathname;
|
|
if(cmSystemTools::FileExists(hname.c_str()))
|
|
{
|
|
sf->SourceName = cmSystemTools::GetFilenamePath(name);
|
|
if ( sf->SourceName.size() > 0 )
|
|
{
|
|
sf->SourceName += "/";
|
|
}
|
|
sf->SourceName += cmSystemTools::GetFilenameWithoutLastExtension(name);
|
|
std::string::size_type pos = hname.rfind('.');
|
|
if(pos != std::string::npos)
|
|
{
|
|
sf->SourceExtension = hname.substr(pos+1, hname.size()-pos);
|
|
if ( cmSystemTools::FileIsFullPath(name) )
|
|
{
|
|
std::string::size_type pos2 = hname.rfind('/');
|
|
if(pos2 != std::string::npos)
|
|
{
|
|
sf->SourceName = hname.substr(pos2+1, pos - pos2-1);
|
|
}
|
|
}
|
|
}
|
|
|
|
sf->FullPath = hname;
|
|
return;
|
|
}
|
|
|
|
// Next, try the various source extensions
|
|
for( std::vector<std::string>::const_iterator ext = sourceExts.begin();
|
|
ext != sourceExts.end(); ++ext )
|
|
{
|
|
hname = pathname;
|
|
hname += ".";
|
|
hname += *ext;
|
|
if(cmSystemTools::FileExists(hname.c_str()))
|
|
{
|
|
sf->SourceExtension = *ext;
|
|
sf->FullPath = hname;
|
|
return;
|
|
}
|
|
}
|
|
|
|
// Finally, try the various header extensions
|
|
for( std::vector<std::string>::const_iterator ext = headerExts.begin();
|
|
ext != headerExts.end(); ++ext )
|
|
{
|
|
hname = pathname;
|
|
hname += ".";
|
|
hname += *ext;
|
|
if(cmSystemTools::FileExists(hname.c_str()))
|
|
{
|
|
sf->SourceExtension = *ext;
|
|
sf->FullPath = hname;
|
|
return;
|
|
}
|
|
}
|
|
|
|
cmOStringStream e;
|
|
e << "Cannot find source file \"" << pathname << "\"";
|
|
e << "\n\nTried extensions";
|
|
for( std::vector<std::string>::const_iterator ext = sourceExts.begin();
|
|
ext != sourceExts.end(); ++ext )
|
|
{
|
|
e << " ." << *ext;
|
|
}
|
|
for( std::vector<std::string>::const_iterator ext = headerExts.begin();
|
|
ext != headerExts.end(); ++ext )
|
|
{
|
|
e << " ." << *ext;
|
|
}
|
|
cmSystemTools::Error(e.str().c_str());
|
|
return;
|
|
}
|
|
|
|
void CCONV cmSourceFileSetName2(void *arg, const char* name, const char* dir,
|
|
const char *ext, int headerFileOnly)
|
|
{
|
|
cmCPluginAPISourceFile* sf = static_cast<cmCPluginAPISourceFile*>(arg);
|
|
if(sf->RealSourceFile)
|
|
{
|
|
// SetName is allowed only on temporary source files created by
|
|
// the command for building and passing to AddSource.
|
|
return;
|
|
}
|
|
|
|
// Implement the old SetName method code here.
|
|
if(headerFileOnly)
|
|
{
|
|
sf->Properties.SetProperty("HEADER_FILE_ONLY", "1",
|
|
cmProperty::SOURCE_FILE);
|
|
}
|
|
sf->SourceName = name;
|
|
std::string fname = sf->SourceName;
|
|
if(ext && strlen(ext))
|
|
{
|
|
fname += ".";
|
|
fname += ext;
|
|
}
|
|
sf->FullPath = cmSystemTools::CollapseFullPath(fname.c_str(), dir);
|
|
cmSystemTools::ConvertToUnixSlashes(sf->FullPath);
|
|
sf->SourceExtension = ext;
|
|
}
|
|
|
|
char * CCONV cmGetFilenameWithoutExtension(const char *name)
|
|
{
|
|
std::string sres = cmSystemTools::GetFilenameWithoutExtension(name);
|
|
char *result = (char *)malloc(sres.size()+1);
|
|
strcpy(result,sres.c_str());
|
|
return result;
|
|
}
|
|
|
|
char * CCONV cmGetFilenamePath(const char *name)
|
|
{
|
|
std::string sres = cmSystemTools::GetFilenamePath(name);
|
|
char *result = (char *)malloc(sres.size()+1);
|
|
strcpy(result,sres.c_str());
|
|
return result;
|
|
}
|
|
|
|
char * CCONV cmCapitalized(const char *name)
|
|
{
|
|
std::string sres = cmSystemTools::Capitalized(name);
|
|
char *result = (char *)malloc(sres.size()+1);
|
|
strcpy(result,sres.c_str());
|
|
return result;
|
|
}
|
|
|
|
void CCONV cmCopyFileIfDifferent(const char *name1, const char *name2)
|
|
{
|
|
cmSystemTools::CopyFileIfDifferent(name1,name2);
|
|
}
|
|
|
|
void CCONV cmRemoveFile(const char *name)
|
|
{
|
|
cmSystemTools::RemoveFile(name);
|
|
}
|
|
|
|
void CCONV cmDisplayStatus(void *arg, const char* message)
|
|
{
|
|
cmMakefile *mf = static_cast<cmMakefile *>(arg);
|
|
mf->DisplayStatus(message, -1);
|
|
}
|
|
|
|
void CCONV cmFree(void *data)
|
|
{
|
|
free(data);
|
|
}
|
|
|
|
void CCONV DefineSourceFileProperty (void *arg, const char *name,
|
|
const char *briefDocs,
|
|
const char *longDocs,
|
|
int chained)
|
|
{
|
|
cmMakefile *mf = static_cast<cmMakefile *>(arg);
|
|
mf->GetCMakeInstance()->DefineProperty(name,cmProperty::SOURCE_FILE,
|
|
briefDocs, longDocs,
|
|
chained != 0);
|
|
}
|
|
|
|
} // close the extern "C" scope
|
|
|
|
cmCAPI cmStaticCAPI =
|
|
{
|
|
cmGetClientData,
|
|
cmGetTotalArgumentSize,
|
|
cmFreeArguments,
|
|
cmSetClientData,
|
|
cmSetError,
|
|
cmAddCacheDefinition,
|
|
cmAddCustomCommand,
|
|
cmAddDefineFlag,
|
|
cmAddDefinition,
|
|
cmAddExecutable,
|
|
cmAddLibrary,
|
|
cmAddLinkDirectoryForTarget,
|
|
cmAddLinkLibraryForTarget,
|
|
cmAddUtilityCommand,
|
|
cmCommandExists,
|
|
cmExecuteCommand,
|
|
cmExpandSourceListArguments,
|
|
cmExpandVariablesInString,
|
|
cmGetCacheMajorVersion,
|
|
cmGetCacheMinorVersion,
|
|
cmGetCurrentDirectory,
|
|
cmGetCurrentOutputDirectory,
|
|
cmGetDefinition,
|
|
cmGetHomeDirectory,
|
|
cmGetHomeOutputDirectory,
|
|
cmGetMajorVersion,
|
|
cmGetMinorVersion,
|
|
cmGetProjectName,
|
|
cmGetStartDirectory,
|
|
cmGetStartOutputDirectory,
|
|
cmIsOn,
|
|
|
|
cmAddSource,
|
|
cmCreateSourceFile,
|
|
cmDestroySourceFile,
|
|
cmGetSource,
|
|
cmSourceFileAddDepend,
|
|
cmSourceFileGetProperty,
|
|
cmSourceFileGetPropertyAsBool,
|
|
cmSourceFileGetSourceName,
|
|
cmSourceFileGetFullPath,
|
|
cmSourceFileSetName,
|
|
cmSourceFileSetName2,
|
|
cmSourceFileSetProperty,
|
|
|
|
cmCapitalized,
|
|
cmCopyFileIfDifferent,
|
|
cmGetFilenameWithoutExtension,
|
|
cmGetFilenamePath,
|
|
cmRemoveFile,
|
|
cmFree,
|
|
|
|
cmAddCustomCommandToOutput,
|
|
cmAddCustomCommandToTarget,
|
|
cmDisplayStatus,
|
|
cmCreateNewSourceFile,
|
|
DefineSourceFileProperty,
|
|
};
|
|
|