CMake/Source/cmCPluginAPI.cxx

935 lines
26 KiB
C++
Raw Normal View History

/*============================================================================
CMake - Cross Platform Makefile Generator
Copyright 2000-2009 Kitware, Inc., Insight Software Consortium
2002-08-21 19:54:06 +04:00
Distributed under the OSI-approved BSD License (the "License");
see accompanying file Copyright.txt for details.
2002-08-21 19:54:06 +04:00
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.
============================================================================*/
2006-03-10 21:06:26 +03:00
/*
2002-08-21 19:54:06 +04:00
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"
2002-08-21 19:54:06 +04:00
2004-02-22 21:14:59 +03:00
#include "cmSourceFile.h"
#include <stdlib.h>
#ifdef __QNX__
# include <malloc.h> /* for malloc/free on QNX */
#endif
2006-03-10 21:06:26 +03:00
extern "C"
2002-08-29 17:45:34 +04:00
{
2006-03-10 21:06:26 +03:00
void CCONV *cmGetClientData(void *info)
2002-08-21 19:54:06 +04:00
{
return ((cmLoadedCommandInfo *)info)->ClientData;
}
void CCONV cmSetClientData(void *info, void *cd)
2002-08-21 19:54:06 +04:00
{
((cmLoadedCommandInfo *)info)->ClientData = cd;
}
void CCONV cmSetError(void *info, const char *err)
2002-10-08 23:55:04 +04:00
{
if (((cmLoadedCommandInfo *)info)->Error)
{
free(((cmLoadedCommandInfo *)info)->Error);
}
((cmLoadedCommandInfo *)info)->Error = strdup(err);
}
unsigned int CCONV cmGetCacheMajorVersion(void *arg)
2002-08-21 19:54:06 +04:00
{
cmMakefile *mf = static_cast<cmMakefile *>(arg);
return mf->GetCacheMajorVersion();
2002-08-21 19:54:06 +04:00
}
unsigned int CCONV cmGetCacheMinorVersion(void *arg)
2002-08-21 19:54:06 +04:00
{
cmMakefile *mf = static_cast<cmMakefile *>(arg);
return mf->GetCacheMinorVersion();
2002-08-21 19:54:06 +04:00
}
unsigned int CCONV cmGetMajorVersion(void *)
2002-08-21 19:54:06 +04:00
{
return cmVersion::GetMajorVersion();
2002-08-21 19:54:06 +04:00
}
unsigned int CCONV cmGetMinorVersion(void *)
2002-08-21 19:54:06 +04:00
{
return cmVersion::GetMinorVersion();
2002-08-21 19:54:06 +04:00
}
void CCONV cmAddDefinition(void *arg, const char* name, const char* value)
2002-08-21 19:54:06 +04:00
{
cmMakefile *mf = static_cast<cmMakefile *>(arg);
mf->AddDefinition(name,value);
}
/* Add a definition to this makefile and the global cmake cache. */
2006-03-10 21:06:26 +03:00
void CCONV cmAddCacheDefinition(void *arg, const char* name,
const char* value, const char* doc, int type)
2002-08-21 19:54:06 +04:00
{
cmMakefile *mf = static_cast<cmMakefile *>(arg);
2006-03-10 21:06:26 +03:00
2002-08-21 19:54:06 +04:00
switch (type)
{
case CM_CACHE_BOOL:
mf->AddCacheDefinition(name,value,doc,
2002-08-21 21:16:07 +04:00
cmCacheManager::BOOL);
2002-08-21 19:54:06 +04:00
break;
case CM_CACHE_PATH:
mf->AddCacheDefinition(name,value,doc,
2002-08-21 21:16:07 +04:00
cmCacheManager::PATH);
2002-08-21 19:54:06 +04:00
break;
case CM_CACHE_FILEPATH:
mf->AddCacheDefinition(name,value,doc,
2002-08-21 21:16:07 +04:00
cmCacheManager::FILEPATH);
2002-08-21 19:54:06 +04:00
break;
case CM_CACHE_STRING:
mf->AddCacheDefinition(name,value,doc,
2002-08-21 21:16:07 +04:00
cmCacheManager::STRING);
2002-08-21 19:54:06 +04:00
break;
case CM_CACHE_INTERNAL:
mf->AddCacheDefinition(name,value,doc,
2002-08-21 21:16:07 +04:00
cmCacheManager::INTERNAL);
2002-08-21 19:54:06 +04:00
break;
case CM_CACHE_STATIC:
mf->AddCacheDefinition(name,value,doc,
2002-08-21 21:16:07 +04:00
cmCacheManager::STATIC);
2002-08-21 19:54:06 +04:00
break;
}
}
const char* CCONV cmGetProjectName(void *arg)
2002-08-21 19:54:06 +04:00
{
cmMakefile *mf = static_cast<cmMakefile *>(arg);
return mf->GetProjectName();
}
const char* CCONV cmGetHomeDirectory(void *arg)
2002-08-21 19:54:06 +04:00
{
cmMakefile *mf = static_cast<cmMakefile *>(arg);
return mf->GetHomeDirectory();
}
const char* CCONV cmGetHomeOutputDirectory(void *arg)
2002-08-21 19:54:06 +04:00
{
cmMakefile *mf = static_cast<cmMakefile *>(arg);
return mf->GetHomeOutputDirectory();
}
const char* CCONV cmGetStartDirectory(void *arg)
2002-08-21 19:54:06 +04:00
{
cmMakefile *mf = static_cast<cmMakefile *>(arg);
return mf->GetStartDirectory();
}
const char* CCONV cmGetStartOutputDirectory(void *arg)
2002-08-21 19:54:06 +04:00
{
cmMakefile *mf = static_cast<cmMakefile *>(arg);
return mf->GetStartOutputDirectory();
}
2006-03-10 21:06:26 +03:00
const char* CCONV cmGetCurrentDirectory(void *arg)
2002-08-21 19:54:06 +04:00
{
cmMakefile *mf = static_cast<cmMakefile *>(arg);
return mf->GetCurrentDirectory();
}
const char* CCONV cmGetCurrentOutputDirectory(void *arg)
2002-08-21 19:54:06 +04:00
{
cmMakefile *mf = static_cast<cmMakefile *>(arg);
return mf->GetCurrentOutputDirectory();
}
const char* CCONV cmGetDefinition(void *arg,const char*def)
2002-08-21 19:54:06 +04:00
{
cmMakefile *mf = static_cast<cmMakefile *>(arg);
return mf->GetDefinition(def);
}
int CCONV cmIsOn(void *arg, const char* name)
2002-08-21 19:54:06 +04:00
{
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)
2002-08-21 19:54:06 +04:00
{
cmMakefile *mf = static_cast<cmMakefile *>(arg);
return static_cast<int>(mf->CommandExists(name));
}
void CCONV cmAddDefineFlag(void *arg, const char* definition)
2002-08-21 19:54:06 +04:00
{
cmMakefile *mf = static_cast<cmMakefile *>(arg);
mf->AddDefineFlag(definition);
}
2006-03-10 21:06:26 +03:00
void CCONV cmAddLinkDirectoryForTarget(void *arg, const char *tgt,
const char* d)
2002-08-21 19:54:06 +04:00
{
cmMakefile *mf = static_cast<cmMakefile *>(arg);
mf->AddLinkDirectoryForTarget(tgt,d);
}
2006-03-10 21:06:26 +03:00
void CCONV cmAddExecutable(void *arg, const char *exename,
2002-08-21 19:54:06 +04:00
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");
}
2002-08-21 19:54:06 +04:00
}
void CCONV cmAddUtilityCommand(void *arg, const char* utilityName,
2002-08-21 19:54:06 +04:00
const char* command,
const char* arguments,
int all,
int numDepends,
const char **depends,
int,
const char **)
2002-08-21 19:54:06 +04:00
{
// 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.
2002-08-21 19:54:06 +04:00
std::vector<std::string> depends2;
for(int i = 0; i < numDepends; ++i)
2002-08-21 19:54:06 +04:00
{
expand = depends[i];
depends2.push_back(mf->ExpandVariablesInString(expand));
2002-08-21 19:54:06 +04:00
}
// Pass the call to the makefile instance.
2007-03-13 22:18:27 +03:00
mf->AddUtilityCommand(utilityName, (all ? false : true),
0, depends2, commandLines);
2002-08-21 19:54:06 +04:00
}
void CCONV cmAddCustomCommand(void *arg, const char* source,
2002-08-21 19:54:06 +04:00
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)
2002-08-21 19:54:06 +04:00
{
expand = args[i];
commandLine.push_back(mf->ExpandVariablesInString(expand));
2002-08-21 19:54:06 +04:00
}
cmCustomCommandLines commandLines;
commandLines.push_back(commandLine);
// Accumulate the list of dependencies.
2002-08-21 19:54:06 +04:00
std::vector<std::string> depends2;
for(int i = 0; i < numDepends; ++i)
2002-08-21 19:54:06 +04:00
{
expand = depends[i];
depends2.push_back(mf->ExpandVariablesInString(expand));
2002-08-21 19:54:06 +04:00
}
// Accumulate the list of outputs.
2002-08-21 19:54:06 +04:00
std::vector<std::string> outputs2;
for(int i = 0; i < numOutputs; ++i)
2002-08-21 19:54:06 +04:00
{
expand = outputs[i];
outputs2.push_back(mf->ExpandVariablesInString(expand));
2002-08-21 19:54:06 +04:00
}
// Pass the call to the makefile instance.
const char* no_comment = 0;
mf->AddCustomCommandOldStyle(target, outputs2, depends2, source,
commandLines, no_comment);
2002-08-21 19:54:06 +04:00
}
void CCONV cmAddCustomCommandToOutput(void *arg, const char* output,
2003-06-03 18:30:23 +04:00
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)
2003-06-03 18:30:23 +04:00
{
expand = args[i];
commandLine.push_back(mf->ExpandVariablesInString(expand));
2003-06-03 18:30:23 +04:00
}
cmCustomCommandLines commandLines;
commandLines.push_back(commandLine);
// Accumulate the list of dependencies.
2003-06-03 18:30:23 +04:00
std::vector<std::string> depends2;
for(int i = 0; i < numDepends; ++i)
2003-06-03 18:30:23 +04:00
{
expand = depends[i];
depends2.push_back(mf->ExpandVariablesInString(expand));
2003-06-03 18:30:23 +04:00
}
// Pass the call to the makefile instance.
const char* no_comment = 0;
2006-02-08 18:58:36 +03:00
const char* no_working_dir = 0;
mf->AddCustomCommandToOutput(output, depends2, main_dependency,
2006-02-08 18:58:36 +03:00
commandLines, no_comment, no_working_dir);
2003-06-03 18:30:23 +04:00
}
void CCONV cmAddCustomCommandToTarget(void *arg, const char* target,
2003-06-03 18:30:23 +04:00
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)
2003-06-03 18:30:23 +04:00
{
expand = args[i];
commandLine.push_back(mf->ExpandVariablesInString(expand));
2003-06-03 18:30:23 +04:00
}
cmCustomCommandLines commandLines;
commandLines.push_back(commandLine);
// Select the command type.
cmTarget::CustomCommandType cctype = cmTarget::POST_BUILD;
2003-06-03 18:30:23 +04:00
switch (commandType)
{
case CM_PRE_BUILD:
cctype = cmTarget::PRE_BUILD;
2003-06-03 18:30:23 +04:00
break;
case CM_PRE_LINK:
cctype = cmTarget::PRE_LINK;
2003-06-03 18:30:23 +04:00
break;
case CM_POST_BUILD:
cctype = cmTarget::POST_BUILD;
2003-06-03 18:30:23 +04:00
break;
}
// Pass the call to the makefile instance.
std::vector<std::string> no_depends;
const char* no_comment = 0;
2006-02-08 18:58:36 +03:00
const char* no_working_dir = 0;
mf->AddCustomCommandToTarget(target, no_depends, commandLines,
2006-02-08 18:58:36 +03:00
cctype, no_comment, no_working_dir);
2003-06-03 18:30:23 +04:00
}
2002-08-21 19:54:06 +04:00
2006-03-10 21:06:26 +03:00
void CCONV cmAddLinkLibraryForTarget(void *arg, const char *tgt,
const char*value, int libtype)
2002-08-21 19:54:06 +04:00
{
cmMakefile *mf = static_cast<cmMakefile *>(arg);
2006-03-10 21:06:26 +03:00
2002-08-21 19:54:06 +04:00
switch (libtype)
{
case CM_LIBRARY_GENERAL:
2002-08-21 21:16:07 +04:00
mf->AddLinkLibraryForTarget(tgt,value, cmTarget::GENERAL);
2002-08-21 19:54:06 +04:00
break;
case CM_LIBRARY_DEBUG:
2002-08-21 21:16:07 +04:00
mf->AddLinkLibraryForTarget(tgt,value, cmTarget::DEBUG);
2002-08-21 19:54:06 +04:00
break;
case CM_LIBRARY_OPTIMIZED:
2002-08-21 21:16:07 +04:00
mf->AddLinkLibraryForTarget(tgt,value, cmTarget::OPTIMIZED);
2002-08-21 19:54:06 +04:00
break;
}
}
void CCONV cmAddLibrary(void *arg, const char *libname, int shared,
2002-08-21 19:54:06 +04:00
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);
2002-08-21 19:54:06 +04:00
}
2006-03-10 21:06:26 +03:00
char CCONV *cmExpandVariablesInString(void *arg, const char *source,
2002-08-21 19:54:06 +04:00
int escapeQuotes, int atOnly)
{
cmMakefile *mf = static_cast<cmMakefile *>(arg);
2002-08-21 21:16:07 +04:00
std::string barf = source;
2006-03-10 21:06:26 +03:00
std::string result =
mf->ExpandVariablesInString(barf,
2002-08-21 19:54:06 +04:00
(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;
}
2006-03-10 21:06:26 +03:00
int CCONV cmExecuteCommand(void *arg, const char *name,
int numArgs, const char **args)
2002-08-21 19:54:06 +04:00
{
cmMakefile *mf = static_cast<cmMakefile *>(arg);
cmListFileFunction lff;
2006-03-15 19:02:08 +03:00
lff.Name = name;
for(int i = 0; i < numArgs; ++i)
2002-08-21 19:54:06 +04:00
{
// Assume all arguments are quoted.
2006-03-15 19:02:08 +03:00
lff.Arguments.push_back(cmListFileArgument(args[i], true,
"[CMake-Plugin]", 0));
2002-08-21 19:54:06 +04:00
}
cmExecutionStatus status;
return mf->ExecuteCommand(lff,status);
2002-08-21 19:54:06 +04:00
}
2006-03-10 21:06:26 +03:00
void CCONV cmExpandSourceListArguments(void *arg,
2002-08-21 19:54:06 +04:00
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);
2002-08-23 23:13:49 +04:00
int resargc = static_cast<int>(result.size());
char **resargv = 0;
2002-08-21 19:54:06 +04:00
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)
2002-08-21 19:54:06 +04:00
{
int i;
for (i = 0; i < argc; ++i)
{
free(argv[i]);
}
if (argv)
{
free(argv);
}
}
int CCONV cmGetTotalArgumentSize(int argc, char **argv)
2002-08-21 19:54:06 +04:00
{
int i;
int result = 0;
for (i = 0; i < argc; ++i)
{
if (argv[i])
{
2002-08-23 23:13:49 +04:00
result = result + static_cast<int>(strlen(argv[i]));
2002-08-21 19:54:06 +04:00
}
}
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(void)
2002-08-21 19:54:06 +04:00
{
return (void*)new cmCPluginAPISourceFile;
2002-08-21 19:54:06 +04:00
}
void * CCONV cmCreateNewSourceFile(void *arg)
2002-08-21 19:54:06 +04:00
{
cmMakefile *mf = static_cast<cmMakefile *>(arg);
cmCPluginAPISourceFile *sf = new cmCPluginAPISourceFile;
sf->Properties.SetCMakeInstance(mf->GetCMakeInstance());
return (void*)sf;
2002-08-21 19:54:06 +04:00
}
void CCONV cmDestroySourceFile(void *arg)
2002-08-21 19:54:06 +04:00
{
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;
}
2002-08-21 19:54:06 +04:00
}
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)
2002-12-11 22:16:55 +03:00
{
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;
2002-12-11 22:16:55 +03:00
}
const char * CCONV cmSourceFileGetSourceName(void *arg)
2002-08-21 19:54:06 +04:00
{
cmCPluginAPISourceFile* sf = static_cast<cmCPluginAPISourceFile*>(arg);
return sf->SourceName.c_str();
2002-08-21 19:54:06 +04:00
}
const char * CCONV cmSourceFileGetFullPath(void *arg)
2002-11-14 19:03:08 +03:00
{
cmCPluginAPISourceFile* sf = static_cast<cmCPluginAPISourceFile*>(arg);
return sf->FullPath.c_str();
2002-11-14 19:03:08 +03:00
}
const char * CCONV cmSourceFileGetProperty(void *arg,const char *prop)
2002-08-21 19:54:06 +04:00
{
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);
}
2002-08-21 19:54:06 +04:00
}
int CCONV cmSourceFileGetPropertyAsBool(void *arg,const char *prop)
2002-08-21 19:54:06 +04:00
{
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;
}
2002-08-21 19:54:06 +04:00
}
2006-03-10 21:06:26 +03:00
void CCONV cmSourceFileSetProperty(void *arg,const char *prop,
const char *value)
2002-08-21 19:54:06 +04:00
{
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);
}
2002-08-21 19:54:06 +04:00
}
void CCONV cmSourceFileAddDepend(void *arg, const char *depend)
2002-08-21 19:54:06 +04:00
{
cmCPluginAPISourceFile* sf = static_cast<cmCPluginAPISourceFile*>(arg);
if(cmSourceFile* rsf = sf->RealSourceFile)
{
rsf->AddDepend(depend);
}
else
{
sf->Depends.push_back(depend);
}
2002-08-21 19:54:06 +04:00
}
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;
2002-08-21 19:54:06 +04:00
int i;
for (i = 0; i < numSourceExtensions; ++i)
{
sourceExts.push_back(sourceExtensions[i]);
2002-08-21 19:54:06 +04:00
}
for (i = 0; i < numHeaderExtensions; ++i)
{
headerExts.push_back(headerExtensions[i]);
2002-08-21 19:54:06 +04:00
}
// 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;
2002-08-21 19:54:06 +04:00
}
2006-03-10 21:06:26 +03:00
void CCONV cmSourceFileSetName2(void *arg, const char* name, const char* dir,
const char *ext, int headerFileOnly)
2002-08-21 19:54:06 +04:00
{
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;
}
2002-08-21 19:54:06 +04:00
// 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;
}
2002-08-21 19:54:06 +04:00
char * CCONV cmGetFilenameWithoutExtension(const char *name)
2002-08-21 19:54:06 +04:00
{
std::string sres = cmSystemTools::GetFilenameWithoutExtension(name);
2006-03-10 21:06:26 +03:00
char *result = (char *)malloc(sres.size()+1);
2002-08-21 19:54:06 +04:00
strcpy(result,sres.c_str());
return result;
}
char * CCONV cmGetFilenamePath(const char *name)
2002-11-14 19:16:58 +03:00
{
std::string sres = cmSystemTools::GetFilenamePath(name);
2006-03-10 21:06:26 +03:00
char *result = (char *)malloc(sres.size()+1);
2002-11-14 19:16:58 +03:00
strcpy(result,sres.c_str());
return result;
}
char * CCONV cmCapitalized(const char *name)
2002-08-21 19:54:06 +04:00
{
std::string sres = cmSystemTools::Capitalized(name);
2006-03-10 21:06:26 +03:00
char *result = (char *)malloc(sres.size()+1);
2002-08-21 19:54:06 +04:00
strcpy(result,sres.c_str());
return result;
}
void CCONV cmCopyFileIfDifferent(const char *name1, const char *name2)
2002-08-21 19:54:06 +04:00
{
cmSystemTools::CopyFileIfDifferent(name1,name2);
}
void CCONV cmRemoveFile(const char *name)
2002-08-21 19:54:06 +04:00
{
cmSystemTools::RemoveFile(name);
}
void CCONV cmDisplayStatus(void *arg, const char* message)
2003-07-22 21:14:55 +04:00
{
cmMakefile *mf = static_cast<cmMakefile *>(arg);
mf->DisplayStatus(message, -1);
2003-07-22 21:14:55 +04:00
}
void CCONV cmFree(void *data)
2002-12-11 22:16:55 +03:00
{
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,
2006-12-07 17:51:28 +03:00
briefDocs, longDocs,
chained != 0);
}
2002-08-29 17:45:34 +04:00
} // close the extern "C" scope
2002-08-26 18:52:04 +04:00
cmCAPI cmStaticCAPI =
{
cmGetClientData,
2002-10-08 23:55:04 +04:00
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,
2006-03-10 21:06:26 +03:00
2002-10-08 23:55:04 +04:00
cmAddSource,
cmCreateSourceFile,
2002-12-11 22:16:55 +03:00
cmDestroySourceFile,
2002-10-08 23:55:04 +04:00
cmGetSource,
cmSourceFileAddDepend,
cmSourceFileGetProperty,
cmSourceFileGetPropertyAsBool,
cmSourceFileGetSourceName,
2002-11-14 19:03:08 +03:00
cmSourceFileGetFullPath,
2002-10-08 23:55:04 +04:00
cmSourceFileSetName,
cmSourceFileSetName2,
cmSourceFileSetProperty,
2006-03-10 21:06:26 +03:00
2002-10-08 23:55:04 +04:00
cmCapitalized,
cmCopyFileIfDifferent,
cmGetFilenameWithoutExtension,
2002-11-14 19:16:58 +03:00
cmGetFilenamePath,
2002-10-08 23:55:04 +04:00
cmRemoveFile,
2002-12-11 22:16:55 +03:00
cmFree,
2003-06-03 18:30:23 +04:00
cmAddCustomCommandToOutput,
cmAddCustomCommandToTarget,
2003-07-23 22:31:30 +04:00
cmDisplayStatus,
cmCreateNewSourceFile,
DefineSourceFileProperty,
2002-08-26 18:52:04 +04:00
};