mirror of
https://github.com/reactos/CMake.git
synced 2024-11-24 20:19:53 +00:00
946 lines
26 KiB
C++
946 lines
26 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.
|
|
|
|
=========================================================================*/
|
|
/*
|
|
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 ? true : false), 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));
|
|
}
|
|
return mf->ExecuteCommand(lff);
|
|
}
|
|
|
|
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)
|
|
{
|
|
(void)arg; // no longer needed
|
|
return (void*)new cmCPluginAPISourceFile;
|
|
}
|
|
|
|
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]);
|
|
}
|
|
|
|
// Implement the old SetName method code here.
|
|
sf->Properties.SetProperty("HEADER_FILE_ONLY", "1",
|
|
cmProperty::SOURCE_FILE);
|
|
|
|
// 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);
|
|
}
|
|
}
|
|
}
|
|
|
|
// See if the file is a header file
|
|
if(std::find( headerExts.begin(), headerExts.end(),
|
|
sf->SourceExtension ) == headerExts.end())
|
|
{
|
|
sf->Properties.SetProperty("HEADER_FILE_ONLY", "0",
|
|
cmProperty::SOURCE_FILE);
|
|
}
|
|
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->Properties.SetProperty("HEADER_FILE_ONLY", "0",
|
|
cmProperty::SOURCE_FILE);
|
|
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.
|
|
sf->Properties.SetProperty("HEADER_FILE_ONLY",
|
|
headerFileOnly? "1" : "0",
|
|
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,
|
|
};
|
|
|