updated to try compile

Source/cmCommands.cxx

@@ -77,6 +77,7 @@
 #include "cmSubdirDependsCommand.cxx"
 #include "cmTargetLinkLibrariesCommand.cxx"
 #include "cmTryCompileCommand.cxx"
+#include "cmTryRunCommand.cxx"
 #include "cmUseMangledMesaCommand.cxx"
 #include "cmUtilitySourceCommand.cxx"
 #include "cmVariableRequiresCommand.cxx"
@@ -159,6 +160,7 @@ void GetPredefinedCommands(std::list<cmCommand*>& commands)
   commands.push_back(new cmSubdirDependsCommand);
   commands.push_back(new cmTargetLinkLibrariesCommand);
   commands.push_back(new cmTryCompileCommand);
+  commands.push_back(new cmTryRunCommand);
   commands.push_back(new cmUseMangledMesaCommand);
   commands.push_back(new cmUtilitySourceCommand);
   commands.push_back(new cmVariableRequiresCommand);

Source/cmTryCompileCommand.cxx

@@ -17,34 +17,12 @@
 #include "cmTryCompileCommand.h"
 #include "cmCacheManager.h"
 
-// cmExecutableCommand
+int cmTryCompileCommand::CoreTryCompileCode(
-bool cmTryCompileCommand::InitialPass(std::vector<std::string> const& argv)
+  cmMakefile *mf, std::vector<std::string> const& argv, bool clean)
 {
-  if(argv.size() < 3)
-    {
-    return false;
-    }
-
   // which signature were we called with ?
   bool srcFileSignature = true;
-  
-  // look for CMAKE_FLAGS and store them
-  std::vector<std::string> cmakeFlags;
   int i;
-  for (i = 3; i < argv.size(); ++i)
-    {
-    if (argv[i] == "CMAKE_FLAGS")
-      {
-      for (; i < argv.size(); ++i)
-        {
-        cmakeFlags.push_back(argv[i]);
-        }
-      }
-    else
-      {
-      srcFileSignature = false;
-      }
-    }
   
   // where will the binaries be stored
   const char* binaryDirectory = argv[1].c_str();
@@ -52,7 +30,7 @@ bool cmTryCompileCommand::InitialPass(std::vector<std::string> const& argv)
   const char* projectName = 0;
   const char* targetName = 0;
   std::string tmpString;
-
+  
   // compute the binary dir when TRY_COMPILE is called with a src file
   // signature
   if (srcFileSignature)
@@ -64,13 +42,54 @@ bool cmTryCompileCommand::InitialPass(std::vector<std::string> const& argv)
   cmSystemTools::MakeDirectory(binaryDirectory);
   
   // do not allow recursive try Compiles
-  if (!strcmp(binaryDirectory,m_Makefile->GetHomeOutputDirectory()))
+  if (!strcmp(binaryDirectory,mf->GetHomeOutputDirectory()))
     {
     cmSystemTools::Error("Attempt at a recursive or nested TRY_COMPILE", 
                          binaryDirectory);
-    return false;
+    return -1;
     }
-      
+  
+  // look for CMAKE_FLAGS and store them
+  std::vector<std::string> cmakeFlags;
+  for (i = 3; i < argv.size(); ++i)
+    {
+    if (argv[i] == "CMAKE_FLAGS")
+      {
+      for (; i < argv.size() && argv[i] != "COMPILE_DEFINITIONS"; 
+           ++i)
+        {
+        cmakeFlags.push_back(argv[i]);
+        }
+      break;
+      }
+    else
+      {
+      srcFileSignature = false;
+      }
+    }
+
+  // look for COMPILE_DEFINITIONS and store them
+  std::vector<std::string> compileFlags;
+  for (i = 0; i < argv.size(); ++i)
+    {
+    if (argv[i] == "COMPILE_DEFINITIONS")
+      {
+      // only valid for srcfile signatures
+      if (!srcFileSignature)
+        {
+        cmSystemTools::Error(
+          "COMPILE_FLAGS specified on a srcdir type TRY_COMPILE");
+        return -1;
+        }
+      for (i = i + 1; i < argv.size() && argv[i] != "CMAKE_FLAGS"; 
+           ++i)
+        {
+        compileFlags.push_back(argv[i]);
+        }
+      break;
+      }
+    }
+  
   // which signature are we using? If we are using var srcfile bindir
   if (srcFileSignature)
     {
@@ -89,13 +108,24 @@ bool cmTryCompileCommand::InitialPass(std::vector<std::string> const& argv)
       {
       cmSystemTools::Error("Failed to create CMakeList file for ", 
                            outFileName.c_str());
-      return false;
+      return -1;
       }
-    fprintf(fout,"PROJECT(CMAKE_TRY_COMPILE)\n");
+    fprintf(fout, "PROJECT(CMAKE_TRY_COMPILE)\n");
     fprintf(fout, "IF (CMAKE_ANSI_CXXFLAGS)\n");
     fprintf(fout, "  SET(CMAKE_CXX_FLAGS \"${CMAKE_CXX_FLAGS} ${CMAKE_ANSI_CXXFLAGS}\")\n");
     fprintf(fout, "ENDIF (CMAKE_ANSI_CXXFLAGS)\n");
-    fprintf(fout,"ADD_EXECUTABLE(cmTryCompileExec \"%s\")\n",argv[2].c_str());
+    // handle any compile flags we need to pass on
+    if (compileFlags.size())
+      {
+      fprintf(fout, "ADD_DEFINITIONS( ");
+      for (i = 0; i < compileFlags.size(); ++i)
+        {
+        fprintf(fout,"%s ",compileFlags[i].c_str());
+        }
+      fprintf(fout, ")\n");
+      }
+    
+    fprintf(fout, "ADD_EXECUTABLE(cmTryCompileExec \"%s\")\n",argv[2].c_str());
     fclose(fout);
     projectName = "CMAKE_TRY_COMPILE";
     targetName = "cmTryCompileExec";
@@ -112,14 +142,14 @@ bool cmTryCompileCommand::InitialPass(std::vector<std::string> const& argv)
     }
   
   // actually do the try compile now that everything is setup
-  int res = m_Makefile->TryCompile(sourceDirectory, binaryDirectory,
+  int res = mf->TryCompile(sourceDirectory, binaryDirectory,
-                                   projectName, targetName, &cmakeFlags);
+                           projectName, targetName, &cmakeFlags);
   
   // set the result var to the return value to indicate success or failure
-  m_Makefile->AddDefinition(argv[0].c_str(), (res == 0 ? "TRUE" : "FALSE"));
+  mf->AddDefinition(argv[0].c_str(), (res == 0 ? "TRUE" : "FALSE"));
-      
+  
-  // if we created a directory etc, then cleanup after ourselves  
+  // if They specified clean then we clean up what we can
-  if (srcFileSignature)
+  if (srcFileSignature && clean)
     {
     cmDirectory dir;
     dir.Load(binaryDirectory);
@@ -137,6 +167,19 @@ bool cmTryCompileCommand::InitialPass(std::vector<std::string> const& argv)
       }
     }
   
+  return res;
+}
+
+// cmExecutableCommand
+bool cmTryCompileCommand::InitialPass(std::vector<std::string> const& argv)
+{
+  if(argv.size() < 3)
+    {
+    return false;
+    }
+
+  cmTryCompileCommand::CoreTryCompileCode(m_Makefile,argv,true);
+  
   return true;
 }
 

Source/cmTryCompileCommand.h

@@ -54,8 +54,15 @@ public:
     {
     return "Try compiling some code";
     }
-  
 
+  /**
+   * This is the core code for try compile. It is here so that other
+   * commands, such as TryRun can access the same logic without
+   * dumplication. 
+   */
+  static int CoreTryCompileCode(
+    cmMakefile *mf, std::vector<std::string> const& argv, bool clean);
+  
   /**
    * More documentation.
    */
@@ -66,8 +73,13 @@ public:
       "Try compiling a program. Return the success or failure in RESULT_VAR "
       "If <target name> is specified then build just that target "
       "otherwise the all or ALL_BUILD target is built.\n"
-      "TRY_COMPILE(RESULT_VAR bindir srcfile <CMAKE_FLAGS <Flags>>)\n"
+      "TRY_COMPILE(RESULT_VAR bindir srcfile\n"
-      "Try compiling a srcfile. Return the success or failure in RESULT_VAR.";
+      "  <CMAKE_FLAGS <Flags>> <COMPILE_DEFINITIONS <flags> ...>)\n"
+      "Try compiling a srcfile. Return the success or failure in RESULT_VAR. "
+      "CMAKE_FLAGS can be used to pass -DVAR:TYPE=VALUE flags to cmake. The "
+      "COMPILE_DEFINITIONS are -Ddefinition that will be passed to the "
+      "compile line. If srcfile is specified the files in bindir/CMakeTmp "
+      "are cleaned.";
     }
   
   cmTypeMacro(cmTryCompileCommand, cmCommand);