summaryrefslogtreecommitdiff
path: root/Source/cmLoadCommandCommand.cxx
diff options
context:
space:
mode:
Diffstat (limited to 'Source/cmLoadCommandCommand.cxx')
-rw-r--r--Source/cmLoadCommandCommand.cxx315
1 files changed, 315 insertions, 0 deletions
diff --git a/Source/cmLoadCommandCommand.cxx b/Source/cmLoadCommandCommand.cxx
new file mode 100644
index 000000000..3a0115c96
--- /dev/null
+++ b/Source/cmLoadCommandCommand.cxx
@@ -0,0 +1,315 @@
+/*============================================================================
+ 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.
+============================================================================*/
+#include "cmLoadCommandCommand.h"
+#include "cmCPluginAPI.h"
+#include "cmCPluginAPI.cxx"
+#include "cmDynamicLoader.h"
+
+#include <cmsys/DynamicLoader.hxx>
+
+#include <stdlib.h>
+
+#ifdef __QNX__
+# include <malloc.h> /* for malloc/free on QNX */
+#endif
+
+#include <signal.h>
+extern "C" void TrapsForSignalsCFunction(int sig);
+
+
+// a class for loadabple commands
+class cmLoadedCommand : public cmCommand
+{
+public:
+ cmLoadedCommand() {
+ memset(&this->info,0,sizeof(this->info));
+ this->info.CAPI = &cmStaticCAPI;
+ }
+
+ ///! clean up any memory allocated by the plugin
+ ~cmLoadedCommand();
+
+ /**
+ * This is a virtual constructor for the command.
+ */
+ virtual cmCommand* Clone()
+ {
+ cmLoadedCommand *newC = new cmLoadedCommand;
+ // we must copy when we clone
+ memcpy(&newC->info,&this->info,sizeof(info));
+ return newC;
+ }
+
+ /**
+ * This is called when the command is first encountered in
+ * the CMakeLists.txt file.
+ */
+ virtual bool InitialPass(std::vector<std::string> const& args,
+ cmExecutionStatus &);
+
+ /**
+ * This is called at the end after all the information
+ * specified by the command is accumulated. Most commands do
+ * not implement this method. At this point, reading and
+ * writing to the cache can be done.
+ */
+ virtual void FinalPass();
+ virtual bool HasFinalPass() const
+ { return this->info.FinalPass? true:false; }
+
+ /**
+ * The name of the command as specified in CMakeList.txt.
+ */
+ virtual const char* GetName() const { return info.Name; }
+
+ /**
+ * Succinct documentation.
+ */
+ virtual const char* GetTerseDocumentation() const
+ {
+ if (this->info.GetTerseDocumentation)
+ {
+ cmLoadedCommand::InstallSignalHandlers(info.Name);
+ const char* ret = info.GetTerseDocumentation();
+ cmLoadedCommand::InstallSignalHandlers(info.Name, 1);
+ return ret;
+ }
+ else
+ {
+ return "LoadedCommand without any additional documentation";
+ }
+ }
+ static const char* LastName;
+ static void TrapsForSignals(int sig)
+ {
+ fprintf(stderr, "CMake loaded command %s crashed with signal: %d.\n",
+ cmLoadedCommand::LastName, sig);
+ }
+ static void InstallSignalHandlers(const char* name, int remove = 0)
+ {
+ cmLoadedCommand::LastName = name;
+ if(!name)
+ {
+ cmLoadedCommand::LastName = "????";
+ }
+
+ if(!remove)
+ {
+ signal(SIGSEGV, TrapsForSignalsCFunction);
+#ifdef SIGBUS
+ signal(SIGBUS, TrapsForSignalsCFunction);
+#endif
+ signal(SIGILL, TrapsForSignalsCFunction);
+ }
+ else
+ {
+ signal(SIGSEGV, 0);
+#ifdef SIGBUS
+ signal(SIGBUS, 0);
+#endif
+ signal(SIGILL, 0);
+ }
+ }
+
+ /**
+ * More documentation.
+ */
+ virtual const char* GetFullDocumentation() const
+ {
+ if (this->info.GetFullDocumentation)
+ {
+ cmLoadedCommand::InstallSignalHandlers(info.Name);
+ const char* ret = info.GetFullDocumentation();
+ cmLoadedCommand::InstallSignalHandlers(info.Name, 1);
+ return ret;
+ }
+ else
+ {
+ return "LoadedCommand without any additional documentation";
+ }
+ }
+
+ cmTypeMacro(cmLoadedCommand, cmCommand);
+
+ cmLoadedCommandInfo info;
+};
+
+extern "C" void TrapsForSignalsCFunction(int sig)
+{
+ cmLoadedCommand::TrapsForSignals(sig);
+}
+
+
+const char* cmLoadedCommand::LastName = 0;
+
+bool cmLoadedCommand::InitialPass(std::vector<std::string> const& args,
+ cmExecutionStatus &)
+{
+ if (!info.InitialPass)
+ {
+ return true;
+ }
+
+ // clear the error string
+ if (this->info.Error)
+ {
+ free(this->info.Error);
+ }
+
+ // create argc and argv and then invoke the command
+ int argc = static_cast<int> (args.size());
+ char **argv = 0;
+ if (argc)
+ {
+ argv = (char **)malloc(argc*sizeof(char *));
+ }
+ int i;
+ for (i = 0; i < argc; ++i)
+ {
+ argv[i] = strdup(args[i].c_str());
+ }
+ cmLoadedCommand::InstallSignalHandlers(info.Name);
+ int result = info.InitialPass((void *)&info,
+ (void *)this->Makefile,argc,argv);
+ cmLoadedCommand::InstallSignalHandlers(info.Name, 1);
+ cmFreeArguments(argc,argv);
+
+ if (result)
+ {
+ return true;
+ }
+
+ /* Initial Pass must have failed so set the error string */
+ if (this->info.Error)
+ {
+ this->SetError(this->info.Error);
+ }
+ return false;
+}
+
+void cmLoadedCommand::FinalPass()
+{
+ if (this->info.FinalPass)
+ {
+ cmLoadedCommand::InstallSignalHandlers(info.Name);
+ this->info.FinalPass((void *)&this->info,(void *)this->Makefile);
+ cmLoadedCommand::InstallSignalHandlers(info.Name, 1);
+ }
+}
+
+cmLoadedCommand::~cmLoadedCommand()
+{
+ if (this->info.Destructor)
+ {
+ cmLoadedCommand::InstallSignalHandlers(info.Name);
+ this->info.Destructor((void *)&this->info);
+ cmLoadedCommand::InstallSignalHandlers(info.Name, 1);
+ }
+ if (this->info.Error)
+ {
+ free(this->info.Error);
+ }
+}
+
+// cmLoadCommandCommand
+bool cmLoadCommandCommand
+::InitialPass(std::vector<std::string> const& args, cmExecutionStatus &)
+{
+ if(args.size() < 1 )
+ {
+ return true;
+ }
+
+ // Construct a variable to report what file was loaded, if any.
+ // Start by removing the definition in case of failure.
+ std::string reportVar = "CMAKE_LOADED_COMMAND_";
+ reportVar += args[0];
+ this->Makefile->RemoveDefinition(reportVar.c_str());
+
+ // the file must exist
+ std::string moduleName =
+ this->Makefile->GetRequiredDefinition("CMAKE_SHARED_MODULE_PREFIX");
+ moduleName += "cm" + args[0];
+ moduleName +=
+ this->Makefile->GetRequiredDefinition("CMAKE_SHARED_MODULE_SUFFIX");
+
+ // search for the file
+ std::vector<std::string> path;
+ for (unsigned int j = 1; j < args.size(); j++)
+ {
+ // expand variables
+ std::string exp = args[j];
+ cmSystemTools::ExpandRegistryValues(exp);
+
+ // Glob the entry in case of wildcards.
+ cmSystemTools::GlobDirs(exp.c_str(), path);
+ }
+
+ // Try to find the program.
+ std::string fullPath = cmSystemTools::FindFile(moduleName.c_str(), path);
+ if (fullPath == "")
+ {
+ cmOStringStream e;
+ e << "Attempt to load command failed from file \""
+ << moduleName << "\"";
+ this->SetError(e.str().c_str());
+ return false;
+ }
+
+ // try loading the shared library / dll
+ cmsys::DynamicLoader::LibraryHandle lib
+ = cmDynamicLoader::OpenLibrary(fullPath.c_str());
+ if(!lib)
+ {
+ std::string err = "Attempt to load the library ";
+ err += fullPath + " failed.";
+ const char* error = cmsys::DynamicLoader::LastError();
+ if ( error )
+ {
+ err += " Additional error info is:\n";
+ err += error;
+ }
+ this->SetError(err.c_str());
+ return false;
+ }
+
+ // Report what file was loaded for this command.
+ this->Makefile->AddDefinition(reportVar.c_str(), fullPath.c_str());
+
+ // find the init function
+ std::string initFuncName = args[0] + "Init";
+ CM_INIT_FUNCTION initFunction
+ = (CM_INIT_FUNCTION)
+ cmsys::DynamicLoader::GetSymbolAddress(lib, initFuncName.c_str());
+ if ( !initFunction )
+ {
+ initFuncName = "_";
+ initFuncName += args[0];
+ initFuncName += "Init";
+ initFunction = (CM_INIT_FUNCTION)(
+ cmsys::DynamicLoader::GetSymbolAddress(lib, initFuncName.c_str()));
+ }
+ // if the symbol is found call it to set the name on the
+ // function blocker
+ if(initFunction)
+ {
+ // create a function blocker and set it up
+ cmLoadedCommand *f = new cmLoadedCommand();
+ (*initFunction)(&f->info);
+ this->Makefile->AddCommand(f);
+ return true;
+ }
+ this->SetError("Attempt to load command failed. "
+ "No init function found.");
+ return false;
+}
+