CMAKE手冊

時間  2019-12-07
標籤 cmake 手冊 简体版
原文   原文鏈接

本博客轉載於：https://www.zybuluo.com/khan-lau/note/254724html


CMake 用法導覽

Preface : 本文是CMake官方文檔CMake Tutorial (http://www.cmake.org/cmake/help/cmake_tutorial.html) 的翻譯。經過一個樣例工程從簡單到複雜的完善過程，文檔介紹了CMake主要模塊（cmake, ctest, cpack）的功能和使用環境；從中能夠一窺cmake的大致形貌。正文以下：前端

本文下述內容是一個手把手的使用指南；它涵蓋了CMake須要解決的公共構建系統的一些問題。這些主題中的許多主題已經在`Mastering CMake一書中以單獨的章節被介紹過，可是經過一個樣例工程看一看它們如何工做也是很是有幫助的。本指南能夠在CMake源碼樹的Tests/Tutorial路徑下找到。每一步都有它本身的子路徑，其中包含該步驟的一個完整的指南。python

1.做爲基礎的起始點（步驟1）

最基本的工程是一個從源代碼文件中構建可執行文件的例子。對於簡單工程，只要一個兩行的CMakeLists文件就足夠了。這將會做爲咱們指南的起點。這份CMakeLists文件看起來像是這樣：linux

 

     
 
  1. cmake_minimum_required (VERSION 2.6)
    2.  
 
  2. project (Tutorial)
    3.  
 
  3. add_executable(Tutorial tutorial.cxx)
    4.  

 

注意到這個例子在CMakeLists文件中使用了小寫。CMake支持大寫、小寫、混合大小寫的命令。tutorial.cxx中的源代碼用來計算一個數的平方根，而且它的初版很是簡單，以下所示：web
 

 

 

     
 
  1. // A simple program that computes the square root of a number
    2.  
 
  2. // 計算一個數的平方根的簡單程序
    3.  
 
  3. #include <stdio.h>
    4.  
 
  4. #include <stdlib.h>
    5.  
 
  5. #include <math.h>
    6.  
 
    7.  
 
  7. int main (int argc, char *argv[]) {
    8.  
 
  8.  if (argc < 2) {
    9.  
 
  9.  fprintf(stdout,"Usage: %s number\n",argv[0]);
    10.  
 
  10.  return 1;
    11.  
 
  11.  }
    12.  
 
  12.  double inputValue = atof(argv[1]);
    13.  
 
  13.  double outputValue = sqrt(inputValue);
    14.  
 
  14.  fprintf(stdout,"The square root of %g is %g\n", inputValue, outputValue);
    15.  
 
  15.  return 0;
    16.  
 
  16. }
    17.  

 

咱們添加的第一個特性用來爲工程和可執行文件指定一個版本號。雖然你能夠在源代碼中惟一指定它，可是你在CMakeLists文件中指定它能夠提供更好的靈活性。以下所示，我麼能夠經過添加一個版本號來修改CMakeLists文件：正則表達式
 

 

 

     
 
  1. cmake_minimum_required (VERSION 2.6)
    2.  
 
  2. project (Tutorial)
    3.  
 
  3. # 版本號
    4.  
 
  4. set (Tutorial_VERSION_MAJOR 1)
    5.  
 
  5. set (Tutorial_VERSION_MINOR 0)
    6.  
 
  6. # 配置一個頭文件，經過它向源代碼中傳遞一些CMake設置。
    7.  
 
  7. configure_file (
    8.  
 
  8.  "${PROJECT_SOURCE_DIR}/TutorialConfig.h.in"
    9.  
 
  9.  "${PROJECT_BINARY_DIR}/TutorialConfig.h"
    10.  
 
  10.  )
    11.  
 
  11. # 將二進制文件樹添加到包含文件的搜索路徑中，這樣咱們能夠找到TutorialConfig.h
    12.  
 
  12. include_directories("${PROJECT_BINARY_DIR}")
    13.  
 
  13. # 添加可執行文件
    14.  
 
  14. add_executable(Tutorial tutorial.cxx)
    15.  

 

因爲配置過的文件將會被寫到二進制文件目錄下，咱們必須把該目錄添加到包含文件的搜索路徑清單中。而後，如下的代碼就能夠在源目錄下建立一份TotorialConfig.h.in文件：shell
 

 

 

     
 
  1. // 與tutorial相關的配置好的選項與設置；
    2.  
 
  2. #define Tutorial_VERSION_MAJOR @Tutorial_VERSION_MAJOR@
    3.  
 
  3. #define Tutorial_VERSION_MINOR @Tutorial_VERSION_MINOR@
    4.  

 

當CMake配置這份頭文件時，@Tutorial_VERSION_MAJOR@和@Tutorial_VERSION_MINOR@的值將會被從CMakeLists文件中傳遞過來的值替代。下一步，咱們要修改tutorial.cxx來包含configured頭文件而後使用其中的版本號。修改過的源代碼展列於下：express
 

 

 

     
 
  1. // 計算平方根的簡單程序。
    2.  
 
  2. #include <stdio.h>
    3.  
 
  3. #include <stdlib.h>
    4.  
 
  4. #include <math.h>
    5.  
 
  5. #include "TutorialConfig.h"
    6.  
 
    7.  
 
  7. int main (int argc, char *argv[]) {
    8.  
 
  8.  if (argc < 2) {
    9.  
 
  9.  fprintf(stdout,"%s Version %d.%d\n",
    10.  
 
  10.  argv[0],
    11.  
 
  11.  Tutorial_VERSION_MAJOR,
    12.  
 
  12.  Tutorial_VERSION_MINOR);
    13.  
 
  13.  fprintf(stdout,"Usage: %s number\n",argv[0]);
    14.  
 
  14.  return 1;
    15.  
 
  15.  }
    16.  
 
  16.  double inputValue = atof(argv[1]);
    17.  
 
  17.  double outputValue = sqrt(inputValue);
    18.  
 
  18.  fprintf(stdout,"The square root of %g is %g\n", inputValue, outputValue);
    19.  
 
  19.  return 0;
    20.  
 
  20. }
    21.  

 

 

2.引入庫（步驟2）
 

如今咱們將會在咱們的工程中引入一個庫。這個庫會包含咱們本身實現的計算一個數的平方根的函數。可執行文件隨後可使用這個庫文件而不是編譯器提供的標準開平方函數。在本指南中，咱們將會把庫文件放到一個子目錄MathFunctions中。它包含下述的單行CMakeLists文件：編程
 

 

 

     
 
  1. add_library(MathFunctions mysqrt.cxx)
    2.  

 

源文件mysqrt.cxx有一個叫作mysqrt的函數，它提供了與編譯器的sqrt函數相似的功能。爲了使用新的庫，咱們在頂層的CMakeLists中增長一個add_subdirectory調用，這樣這個庫也會被構建。咱們也要向可執行文件中增長另外一個頭文件路徑，這樣就能夠從MathFunctions/mysqrt.h頭文件中找到函數的原型。最後的一點更改是在向可執行文件中引入新的庫。頂層CMakeLists文件的最後幾行如今看起來像是這樣：windows
 

 

 

     
 
  1. include_directories ("${PROJECT_SOURCE_DIR}/MathFunctions")
    2.  
 
  2. add_subdirectory (MathFunctions) 
    3.  
 
  3. # 引入可執行文件
    4.  
 
  4. add_executable (Tutorial tutorial.cxx)
    5.  
 
  5. target_link_libraries (Tutorial MathFunctions)
    6.  

 

如今，讓咱們考慮下讓MathFunctions庫變爲可選的。在本指南中，確實沒有必要這樣多此一舉；可是對於更大型的庫或者依賴於第三方代碼的庫，你可能須要這種可選擇性。第一步是爲頂層的CMakeLists文件添加一個選項：
 

 

 

     
 
  1. # 咱們應該使用咱們本身的數學函數嗎？
    2.  
 
  2. option (USE_MYMATH "Use tutorial provided math implementation" ON) 
    3.  

 

這將會在CMake的GUI中顯示一個默認的ON值，而且用戶能夠隨需改變這個設置。這個設置會被存儲在cache中，那麼用戶將不須要在cmake該工程時，每次都設置這個選項。第二處改變是，讓連接MathFunctions庫變爲可選的。要實現這一點，咱們修改頂層CMakeLists文件的結尾部分：
 

 

 

     
 
  1. # 添加MathFunctions庫嗎？
    2.  
 
  2. if (USE_MYMATH)
    3.  
 
  3.  include_directories ("${PROJECT_SOURCE_DIR}/MathFunctions")
    4.  
 
  4.  add_subdirectory (MathFunctions)
    5.  
 
  5.  set (EXTRA_LIBS ${EXTRA_LIBS} MathFunctions)
    6.  
 
  6. endif (USE_MYMATH)
    7.  
 
  7. # 添加可執行文件
    8.  
 
  8. add_executable (Tutorial tutorial.cxx)
    9.  
 
  9. target_link_libraries (Tutorial ${EXTRA_LIBS})
    10.  

 

這裏用USE_MYMATH設置來決定是否MathFunctions應該被編譯和執行。注意到，要用一個變量（在這裏是EXTRA_LIBS）來收集全部之後會被鏈接到可執行文件中的可選的庫。這是保持帶有許多可選部件的較大型工程乾淨清爽的一種通用的方法。源代碼對應的改變至關直白，以下所示：
 

 

 

     
 
  1. // 計算一個數平方根的簡單程序
    2.  
 
  2. #include <stdio.h>
    3.  
 
  3. #include <stdlib.h>
    4.  
 
  4. #include <math.h>
    5.  
 
  5. #include "TutorialConfig.h"
    6.  
 
  6. #ifdef USE_MYMATH
    7.  
 
  7. #include "MathFunctions.h"
    8.  
 
  8. #endif
    9.  
 
    10.  
 
  10. int main (int argc, char *argv[]) {
    11.  
 
  11.  if (argc < 2) {
    12.  
 
  12.  fprintf(stdout,"%s Version %d.%d\n", argv[0],
    13.  
 
  13.  Tutorial_VERSION_MAJOR,
    14.  
 
  14.  Tutorial_VERSION_MINOR);
    15.  
 
  15.  fprintf(stdout,"Usage: %s number\n",argv[0]);
    16.  
 
  16.  return 1;
    17.  
 
  17.  }
    18.  
 
    19.  
 
  19.  double inputValue = atof(argv[1]);
    20.  
 
    21.  
 
  21. #ifdef USE_MYMATH
    22.  
 
  22.  double outputValue = mysqrt(inputValue);
    23.  
 
  23. #else
    24.  
 
  24.  double outputValue = sqrt(inputValue);
    25.  
 
  25. #endif
    26.  
 
    27.  
 
  27.  fprintf(stdout,"The square root of %g is %g\n", inputValue, outputValue);
    28.  
 
  28.  return 0;
    29.  
 
  29. }
    30.  

 

在源代碼中，咱們也使用了USE_MYMATH。這個宏是由CMake經過TutorialConfig.h.in配置文件中的下述語句行提供給源代碼的：
 

 

 

     
 
  1. #cmakedefine USE_MYMATH
    2.  

 

 

3.安裝與測試（步驟3）
 

下一步咱們會爲咱們的工程引入安裝規則以及測試支持。安裝規則至關直白，對於MathFunctions庫，咱們經過向MathFunctions的CMakeLists文件添加以下兩條語句來設置要安裝的庫以及頭文件：
 

 

 

     
 
  1. install (TARGETS MathFunctions DESTINATION bin)
    2.  
 
  2. install (FILES MathFunctions.h DESTINATION include)
    3.  

 

對於應用程序，在頂層CMakeLists文件中添加下面幾行，它們用來安裝可執行文件以及配置頭文件：
 

 

 

     
 
  1. # 添加安裝目標
    2.  
 
  2. install (TARGETS Tutorial DESTINATION bin)
    3.  
 
  3. install (FILES "${PROJECT_BINARY_DIR}/TutorialConfig.h" DESTINATION include)
    4.  

 

這就是要作的所有；如今你應該能夠構建tutorial工程了。而後，敲入命令make install（或者從IDE中構建INSTALL目標）而後它就會安裝須要的頭文件，庫以及可執行文件CMake的變量CMAKE_INSTALL_PREFIX用來肯定這些文件被安裝的根目錄。添加測試一樣也只須要至關淺顯的過程。在頂層CMakeLists文件的的尾部補充許多基本的測試代碼來確認應用程序能夠正確工做。
 

 

 

     
 
  1. # 應用程序是否運行?
    2.  
 
  2. add_test (TutorialRuns Tutorial 25)
    3.  
 
    4.  
 
  4. # 它是否對25作了開平方運算
    5.  
 
  5. add_test (TutorialComp25 Tutorial 25)
    6.  
 
    7.  
 
  7. set_tests_properties (TutorialComp25 
    8.  
 
  8.  PROPERTIES PASS_REGULAR_EXPRESSION "25 is 5")
    9.  
 
    10.  
 
  10. # 它是否能處理是負數做爲輸入的狀況
    11.  
 
  11. add_test (TutorialNegative Tutorial -25)
    12.  
 
  12. set_tests_properties (TutorialNegative
    13.  
 
  13.  PROPERTIES PASS_REGULAR_EXPRESSION "-25 is 0")
    14.  
 
    15.  
 
  15. # 它是否能夠處理較小的數字。
    16.  
 
  16. add_test (TutorialSmall Tutorial 0.0001)
    17.  
 
  17. set_tests_properties (TutorialSmall
    18.  
 
  18.  PROPERTIES PASS_REGULAR_EXPRESSION "0.0001 is 0.01")
    19.  
 
    20.  
 
  20. # 用法信息是否可用？
    21.  
 
  21. add_test (TutorialUsage Tutorial)
    22.  
 
  22. set_tests_properties (TutorialUsage
    23.  
 
  23.  PROPERTIES 
    24.  
 
  24.  PASS_REGULAR_EXPRESSION "Usage:.*number")
    25.  

 

第一個測試用例僅僅用來驗證程序能夠運行，沒有出現段錯誤或其餘的崩潰，而且返回值必須是0。這是CTest所作測試的基本格式。餘下的幾個測試都是用PASS_REGULAR_EXPRESSION 測試屬性來驗證測試代碼的輸出是否包含有特定的字符串。在本例中，測試樣例用來驗證計算得出的平方根與預約值同樣；當指定錯誤的輸入數據時，要打印用法信息。若是你想要添加許多測試不一樣輸入值的樣例，你應該考慮建立以下所示的宏：
 

 

 

     
 
  1. #定義一個宏來簡化添加測試的過程，而後使用它
    2.  
 
  2. macro (do_test arg result)
    3.  
 
  3.  add_test (TutorialComp${arg} Tutorial ${arg})
    4.  
 
  4.  set_tests_properties (TutorialComp${arg}
    5.  
 
  5.  PROPERTIES PASS_REGULAR_EXPRESSION ${result})
    6.  
 
  6. endmacro (do_test)
    7.  
 
  7. # 作一系列基於結果的測試
    8.  
 
  8. do_test (25 "25 is 5")
    9.  
 
  9. do_test (-25 "-25 is 0")
    10.  

 

對於每一個do_test宏調用，都會向工程中添加一個新的測試用例；宏參數是測試名、函數的輸入以及指望結果。
 

 

4.增長系統內省（步驟4）
 

下一步，讓咱們考慮向咱們的工程中引入一些依賴於目標平臺上可能不具有的特性的代碼。在本例中，咱們會增長一些依賴於目標平臺是否有log或exp函數的代碼。固然，幾乎每一個平臺都有這些函數；可是對於tutorial工程，咱們假設它們並不是如此廣泛。若是該平臺有log函數，那麼咱們會在mysqrt函數中使用它去計算平方根。咱們首先在頂層CMakeLists文件中使用宏CheckFunctionExists.cmake測試這些函數的可用性：
 

 

 

     
 
  1. # 該系統提供log和exp函數嗎？
    2.  
 
  2. include (CheckFunctionExists.cmake)
    3.  
 
  3. check_function_exists (log HAVE_LOG)
    4.  
 
  4. check_function_exists (exp HAVE_EXP)
    5.  

 

下一步，若是CMake在對應平臺上找到了它們，咱們修改TutorialConfig.h.in來定義這些值；以下：
 

 

 

     
 
  1. // 該平臺提供exp和log函數嗎？
    2.  
 
  2. #cmakedefine HAVE_LOG
    3.  
 
  3. #cmakedefine HAVE_EXP
    4.  

 

這些log和exp函數的測試要在TutorialConfig.h的configure_file命令以前被處理，這一點很重要。最後，在mysqrt函數中，若是log和exp在當前系統上可用的話，咱們能夠提供一個基於它們的可選的實現：
 

 

 

     
 
  1. // 若是咱們有log和exp兩個函數，那麼使用它們
    2.  
 
  2. #if defined (HAVE_LOG) && defined (HAVE_EXP)
    3.  
 
  3.  result = exp(log(x)*0.5);
    4.  
 
  4. #else // 不然使用替代方法
    5.  

 

 

5.添加一個生成文件以及生成器（步驟5）
 

在本節，咱們會展現你應該怎樣向一個應用程序的構建過程當中添加一個生成的源文件。在本範例中，咱們會建立一個預先計算出的平方根表做爲構建過程的一部分。MathFunctions子路徑下，一個新的MakeTable.cxx源文件來作這件事。
 

 

 

     
 
  1. // 一個簡單的用於構建平方根表的程序
    2.  
 
  2. #include <stdio.h>
    3.  
 
  3. #include <stdlib.h>
    4.  
 
  4. #include <math.h>
    5.  
 
    6.  
 
  6. int main (int argc, char *argv[]) {
    7.  
 
  7.  int i;
    8.  
 
  8.  double result;
    9.  
 
    10.  
 
  10.  // 確保有足夠多的參數
    11.  
 
  11.  if (argc < 2) {
    12.  
 
  12.  return 1;
    13.  
 
  13.  }
    14.  
 
    15.  
 
  15.  // 打開輸出文件
    16.  
 
  16.  FILE *fout = fopen(argv[1],"w");
    17.  
 
  17.  if (!fout) {
    18.  
 
  18.  return 1;
    19.  
 
  19.  }
    20.  
 
    21.  
 
  21.  // 建立一個帶有平方根表的源文件
    22.  
 
  22.  fprintf(fout,"double sqrtTable[] = {\n");
    23.  
 
  23.  for (i = 0; i < 10; ++i) {
    24.  
 
  24.  result = sqrt(static_cast<double>(i));
    25.  
 
  25.  fprintf(fout,"%g,\n",result);
    26.  
 
  26.  }
    27.  
 
    28.  
 
  28.  // 該表以0結尾
    29.  
 
  29.  fprintf(fout,"0};\n");
    30.  
 
  30.  fclose(fout);
    31.  
 
  31.  return 0;
    32.  
 
  32. }
    33.  

 

注意到這個表是由合法的C++代碼生成的，而且被寫入的輸出文件的名字是做爲一個參數輸入的。下一步是將合適的命令添加到MathFunction的CMakeLists文件中，來構建MakeTable可執行文件，而後運行它，做爲構建過程的一部分。完成這幾步，須要少數的幾個命令，以下所示：
 

 

 

     
 
  1. # 首先，咱們添加生成該表的可執行文件
    2.  
 
  2. add_executable(MakeTable MakeTable.cxx) 
    3.  
 
  3. # 而後添加該命令來生成源文件
    4.  
 
  4. add_custom_command (
    5.  
 
  5.  OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/Table.h
    6.  
 
  6.  COMMAND MakeTable ${CMAKE_CURRENT_BINARY_DIR}/Table.h
    7.  
 
  7.  DEPENDS MakeTable
    8.  
 
  8.  )
    9.  
 
    10.  
 
  10. # 爲包含文件，向搜索路徑中添加二進制樹路徑
    11.  
 
  11. include_directories( ${CMAKE_CURRENT_BINARY_DIR} )
    12.  
 
    13.  
 
  13. # 添加main庫
    14.  
 
  14. add_library(MathFunctions mysqrt.cxx ${CMAKE_CURRENT_BINARY_DIR}/Table.h )
    15.  

 

首先，MakeTable的可執行文件也和其餘被加入的文件同樣被加入。而後，咱們添加一個自定義命令來指定如何經過運行MakeTable來生成Table.h。這是經過將生成Table.h增長到MathFunctions庫的源文件列表中來實現的。咱們還必須增長當前的二進制路徑到包含路徑的清單中，這樣Table.h能夠被找到而且能夠被mysqrt.cxx所包含。當該工程被構建後，它首先會構建MakeTable可執行文件。而後它會運行MakeTable來生成Table.h文件。最後，它會編譯mysqrt.cxx（其中包含Table.h）來生成MathFunctions庫。到目前爲止，擁有咱們添加的完整特性的頂層CMakeLists文件看起來像是這樣：
 

 

 

     
 
  1. cmake_minimum_required (VERSION 2.6)
    2.  
 
  2. project (Tutorial)
    3.  
 
    4.  
 
  4. # 版本號
    5.  
 
  5. set (Tutorial_VERSION_MAJOR 1)
    6.  
 
  6. set (Tutorial_VERSION_MINOR 0)
    7.  
 
    8.  
 
  8. # 本系統是否提供log和exp函數?
    9.  
 
  9. include (${CMAKE_ROOT}/Modules/CheckFunctionExists.cmake)
    10.  
 
    11.  
 
  11. check_function_exists (log HAVE_LOG)
    12.  
 
  12. check_function_exists (exp HAVE_EXP)
    13.  
 
    14.  
 
  14. # 咱們應該使用本身的math函數嗎?
    15.  
 
  15. option(USE_MYMATH 
    16.  
 
  16.  "Use tutorial provided math implementation" ON)
    17.  
 
    18.  
 
  18. # 配置一個頭文件來向源代碼傳遞一些CMake設置。
    19.  
 
  19. configure_file (
    20.  
 
  20.  "${PROJECT_SOURCE_DIR}/TutorialConfig.h.in"
    21.  
 
  21.  "${PROJECT_BINARY_DIR}/TutorialConfig.h"
    22.  
 
  22.  )
    23.  
 
    24.  
 
  24. # 爲包含文件的搜索路徑添加二進制樹，這樣才能發現TutorialConfig.h頭文件。
    25.  
 
  25. include_directories ("${PROJECT_BINARY_DIR}")
    26.  
 
    27.  
 
  27. # 添加MathFunctions庫嗎?
    28.  
 
  28. if (USE_MYMATH)
    29.  
 
  29.  include_directories ("${PROJECT_SOURCE_DIR}/MathFunctions")
    30.  
 
  30.  add_subdirectory (MathFunctions)
    31.  
 
  31.  set (EXTRA_LIBS ${EXTRA_LIBS} MathFunctions)
    32.  
 
  32. endif (USE_MYMATH)
    33.  
 
    34.  
 
  34. # 添加可執行文件
    35.  
 
  35. add_executable (Tutorial tutorial.cxx)
    36.  
 
  36. target_link_libraries (Tutorial ${EXTRA_LIBS})
    37.  
 
    38.  
 
  38. # 添加安裝的目標
    39.  
 
  39. install (TARGETS Tutorial DESTINATION bin)
    40.  
 
  40. install (FILES "${PROJECT_BINARY_DIR}/TutorialConfig.h" 
    41.  
 
  41.  DESTINATION include)
    42.  
 
    43.  
 
  43. # 測試1 ：應用程序能夠運行嗎?
    44.  
 
  44. add_test (TutorialRuns Tutorial 25)
    45.  
 
    46.  
 
  46. # 測試2 ： 使用信息可用嗎?
    47.  
 
  47. add_test (TutorialUsage Tutorial)
    48.  
 
  48. set_tests_properties (TutorialUsage
    49.  
 
  49.  PROPERTIES 
    50.  
 
  50.  PASS_REGULAR_EXPRESSION "Usage:.*number"
    51.  
 
  51.  )
    52.  
 
    53.  
 
  53. # 定義一個能夠簡化引入測試過程的宏
    54.  
 
  54. macro (do_test arg result)
    55.  
 
  55.  add_test (TutorialComp${arg} Tutorial ${arg})
    56.  
 
  56.  set_tests_properties (TutorialComp${arg}
    57.  
 
  57.  PROPERTIES PASS_REGULAR_EXPRESSION ${result}
    58.  
 
  58.  )
    59.  
 
  59. endmacro (do_test)
    60.  
 
    61.  
 
  61. # do a bunch of result based tests
    62.  
 
  62. # 執行一系列基於結果的測試
    63.  
 
  63. do_test (4 "4 is 2")
    64.  
 
  64. do_test (9 "9 is 3")
    65.  
 
  65. do_test (5 "5 is 2.236")
    66.  
 
  66. do_test (7 "7 is 2.645")
    67.  
 
  67. do_test (25 "25 is 5")
    68.  
 
  68. do_test (-25 "-25 is 0")
    69.  
 
  69. do_test (0.0001 "0.0001 is 0.01")
    70.  

 

TutorialConfig.h文件看起來像是這樣：
 

 

 

     
 
  1. // Tutorial的配置選項與設置以下
    2.  
 
  2. #define Tutorial_VERSION_MAJOR @Tutorial_VERSION_MAJOR@
    3.  
 
  3. #define Tutorial_VERSION_MINOR @Tutorial_VERSION_MINOR@
    4.  
 
  4. #cmakedefine USE_MYMATH
    5.  
 
    6.  
 
  6. // 該平臺提供exp和log函數嗎?
    7.  
 
  7. #cmakedefine HAVE_LOG
    8.  
 
  8. #cmakedefine HAVE_EXP
    9.  

 

而後，MathFunctions工程的CMakeLists文件看起來像是這樣：
 

 

 

     
 
  1. # 首先，咱們添加生成這個表的可執行文件
    2.  
 
  2. add_executable(MakeTable MakeTable.cxx)
    3.  
 
  3. # 添加生成源代碼的命令
    4.  
 
  4. add_custom_command (
    5.  
 
  5.  OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/Table.h
    6.  
 
  6.  DEPENDS MakeTable
    7.  
 
  7.  COMMAND MakeTable ${CMAKE_CURRENT_BINARY_DIR}/Table.h
    8.  
 
  8.  )
    9.  
 
  9. # 爲包含文件向搜索路徑中添加二進制樹目錄
    10.  
 
  10. include_directories( ${CMAKE_CURRENT_BINARY_DIR} )
    11.  
 
    12.  
 
  12. # 添加main庫
    13.  
 
  13. add_library(MathFunctions mysqrt.cxx ${CMAKE_CURRENT_BINARY_DIR}/Table.h) 
    14.  
 
  14. install (TARGETS MathFunctions DESTINATION bin)
    15.  
 
  15. install (FILES MathFunctions.h DESTINATION include)
    16.  

 

 

6.構建一個安裝器（步驟6）
 

下一步假設咱們想要向其餘人分發咱們的工程，這樣他們就可使用它。咱們想同時提供在許多不一樣平臺上的源代碼和二進制文檔發行版。這與以前咱們在「安裝與測試（步驟3）」作過的安裝有一點不一樣，那裏咱們僅僅安裝咱們從源碼中構建出來的二進制文件。在本例子中，咱們會構建支持二進制安裝以及相似於cygwin，debian，RPM等具備包管理特性的安裝包。爲了完成這個目標，咱們會使用CPack來建立Packaging with CPack一章中描述的特定平臺的安裝器。
 

 

 

     
 
  1. # 構建一個CPack驅動的安裝包
    2.  
 
  2. include (InstallRequiredSystemLibraries)
    3.  
 
  3. set (CPACK_RESOURCE_FILE_LICENSE
    4.  
 
  4.  "${CMAKE_CURRENT_SOURCE_DIR}/License.txt")
    5.  
 
  5. set (CPACK_PACKAGE_VERSION_MAJOR "${Tutorial_VERSION_MAJOR}")
    6.  
 
  6. set (CPACK_PACKAGE_VERSION_MINOR "${Tutorial_VERSION_MINOR}")
    7.  
 
  7. include (CPack)
    8.  

 

須要作的所有事情就這些。咱們以包含InstallRequiredSystemLibraries開始。這個模塊將會包含許多在當前平臺上，當前工程須要的運行時庫。第一步咱們將一些CPack變量設置爲保存本工程的許可證和版本信息的位置。版本信息使用了咱們在本指南中先前設置的變量。最後，咱們要包含CPack模塊，它會使用這些變量以及你所處的系統的一些別的屬性，而後來設置一個安裝器。下一步是以一般的方式構建該工程而後隨後運行CPack。若是要構建一個二進制發行包，你應該運行：
 

 

 

     
 
  1. cpack -C CPackConfig.cmake
    2.  

 

爲了建立一個源代碼發行版，你應該鍵入：
 

 

 

     
 
  1. cpack -C CPackSourceConfig.cmake
    2.  

 

 

7.增長對Dashboard的支持（步驟7）
 

增長對向一個dashboard提交咱們的測試結果的功能的支持很是簡單。咱們在本指南的先前步驟中已經定義了咱們工程中的許多測試樣例。咱們僅僅須要運行這些測試樣例而後將它們提交到dashboard便可。爲了包含對dashboards的支持，咱們須要在頂層CMakeLists文件中包含CTest模塊。
 

 

 

     
 
  1. # 支持dashboard腳本
    2.  
 
  2. include (CTest)
    3.  

 

咱們也能夠建立一個CTestConfig.cmake文件，在其中來指定該dashboard的工程名。
 

 

 

     
 
  1. set (CTEST_PROJECT_NAME "Tutorial")
    2.  

 

CTest 將會在運行期間讀取這個文件。爲了建立一個簡單的dashboard，你能夠在你的工程下運行CMake，而後切換到二進制樹，而後運行ctest -DExperimental. 你的dashboard將會被更新到Kitware的公共dashboard.
 

 

cmake指令
 

公司的一個項目使用CMake做爲跨平臺構建工具；業務有需求，固然要好好研讀一下官方的技術手冊。目前的計劃是先把官方手冊翻譯一下，瞭解清楚CMake中的各類命令、屬性和變量的用法。同時在工做中也會閱讀CMake的真實源碼，後續會基於此陸續寫一些工程中使用CMake的心得。CMake的版本也在不停更新，有些新的命令和變量會隨着版本更新添加進來，這是後事了，暫且無論；如今鎖定CMake 2.8.3做爲手冊翻譯的版本。
 

 

命令名稱
 

 

 

     
 
  1. cmake - 跨平臺Makefile生成工具。
    2.  

 

 

用法
 

 

 

     
 
  1. 　　cmake [選項] <源碼路徑>
    2.  
 
  2. 　　cmake [選項] <現有構建路徑>
    3.  

 

 

描述
 

cmake可執行程序是CMake的命令行界面。它能夠用腳本對工程進行配置。工程配置設置能夠在命令行中使用-D選項指定。使用-i選項，cmake將經過提示交互式地完成該設置。
 

CMake是一個跨平臺的構建系統生成工具。它使用平臺無關的CMake清單文件CMakeLists.txt，指定工程的構建過程；源碼樹的每一個路徑下都有這個文件。CMake產生一個適用於具體平臺的構建系統，用戶使用這個系統構建本身的工程。
 

 

選項
 

 

 

 

     
 
  1. -C <initial-cache>: 預加載一個腳本填充緩存文件。
    2.  
 
  2. 　　當cmake在一個空的構建樹上第一次運行時，它會建立一個CMakeCache.txt文件，而後向其中寫入可定製的項目設置數據。-C選項能夠用來指定一個文件，在第一次解析這個工程的cmake清單文件時，從這個文件加載緩存的條目(cache entries)信息。被加載的緩存條目比項目默認的值有更高的優先權。參數中給定的那個文件應該是一個CMake腳本，其中包含有使用CACHE選項的SET命令；而不是一個緩存格式的文件。
    3.  
 
    4.  
 
  4. -D <var>:<type>=<value>: 建立一個CMake的緩存條目。
    5.  
 
  5. 　　當cmake第一次運行於一個空的構建數時，它會建立一個CMakeCache.txt文件，而且使用可定製的工程設置來填充這個文件。這個選項能夠用來指定優先級高於工程的默認值的工程設置值。這個參數能夠被重複屢次，用來填充所須要數量的緩存條目(cache entries)。
    6.  
 
    7.  
 
  7. -U <globbing_expr>: 從CMake的緩存文件中刪除一條匹配的條目。
    8.  
 
  8. 　　該選項能夠用來刪除CMakeCache.txt文件中的一或多個變量。文件名匹配表達式(globbing expression)支持通配符*和?的使用。該選項能夠重複屢次以刪除指望數量的緩存條目。使用它時要當心，你可能所以讓本身的CMakeCache.txt罷工。
    9.  
 
    10.  
 
  10. -G <generator-name>: 指定一個makefile生成工具。
    11.  
 
  11. 　　在具體的平臺上，CMake能夠支持多個原生的構建系統。makefile生成工具的職責是生成特定的構建系統。可能的生成工具的名稱將在生成工具一節給出。
    12.  
 
    13.  
 
  13. -Wno-dev: 抑制開發者警告。
    14.  
 
  14. 　　抑制那些爲CMakeLists.txt文件的做者準備的警告信息。
    15.  
 
    16.  
 
  16. -Wdev: 使能開發者警告信息輸出功能。
    17.  
 
  17. 　　容許那些爲CMakeLists.txt文件的做者準備的警告信息。
    18.  
 
    19.  
 
  19. -E: CMake命令行模式。
    20.  
 
  20. 　　爲了真正作到與平臺無關，CMake提供了一系列能夠用於全部系統上的的命令。以-E參數運行CMake會幫助你得到這些命令的用法。可使用的命令有：chdir, copy, copy_if_different copy_directory, compare_files, echo, echo_append, environment, make_directory, md5sum, remove_directory, remove, tar, time, touch, touch_nocreate, write_regv, delete_regv, comspec, create_symlink。
    21.  
 
    22.  
 
  22. -i: 以嚮導模式運行CMake。
    23.  
 
  23. 　　嚮導模式是在沒有GUI時，交互式地運行cmake的模式。cmake會彈出一系列的提示，要求用戶回答關於工程配置的一行問題。這些答覆會被用來設置cmake的緩存值。
    24.  
 
    25.  
 
  25. -L[A][H]: 列出緩存的變量中的非高級的變量。
    26.  
 
  26. 　　-L選項會列出緩存變量會運行CMake，並列出全部CMake的內有被標記爲INTERNAL或者ADVANCED的緩存變量。這會顯示當前的CMake配置信息，而後你能夠用-D選項改變這些選項。修改一些變量可能會引發更多的變量被建立出來。若是指定了A選項，那麼命令也會顯示高級變量。若是指定了H選項，那麼命令會顯示每一個變量的幫助信息。
    27.  
 
  27. 　　
    28.  
 
    29.  
 
  29. --build <dir>: 構建由CMake生成的工程的二進制樹。（這個選項的含義我不是很清楚—譯註）
    30.  
 
  30.  該選項用如下的選項歸納了內置構建工具的命令行界面
    31.  
 
  31.  <dir> = 待建立的工程二進制路徑。
    32.  
 
    33.  
 
  33.  --target <tgt> = 構建<tgt>，而不是默認目標。
    34.  
 
  34.  --config <cfg> = 對於多重配置工具，選擇配置<cfg>。
    35.  
 
  35.  --clean-first = 首先構建目標的clean僞目標，而後再構建。
    36.  
 
  36.  （若是僅僅要clean掉，使用--target 'clean'選項。）
    37.  
 
    38.  
 
  38.  -- = 向內置工具（native tools）傳遞剩餘的選項。
    39.  
 
    40.  
 
  40.  運行不帶選項的cmake --build來獲取快速幫助信息。
    41.  
 
  41. -N: 查看模式。
    42.  
 
  42.  僅僅加載緩存信息，並不實際運行配置和生成步驟。
    43.  
 
    44.  
 
  44. -P <file>: 處理腳本模式。
    45.  
 
  45.  將給定的cmake文件按照CMake語言編寫的腳本進行處理。不執行配置和生成步驟，不修改緩存信息。若是要使用-D選項定義變量，-D選項必須在-P選項以前。
    46.  
 
    47.  
 
  47. --graphviz=[file]: 生成依賴的graphviz圖。
    48.  
 
  48.  生成一個graphviz軟件的輸入文件，其中包括了項目中全部庫和可執行文件之間的依賴關係。
    49.  
 
    50.  
 
  50. --system-information [file]: 輸出與該系統相關的信息。
    51.  
 
  51.  輸出範圍比較廣的、與當前使用的系統有關的信息。若是在一個CMake工程的二進制構建樹的頂端運行該命令，它還會打印一些附加信息，例如緩存，日誌文件等等。
    52.  
 
    53.  
 
  53. --debug-trycompile: 不刪除「嘗試編譯」路徑。
    54.  
 
  54.  不刪除那些爲try_compile調用生成的路徑。這在調試失敗的try_compile文件時比較有用。不過，由於上一次「嘗試編譯」生成的舊的垃圾輸出文件也許會致使一次不正確經過/不經過，且該結果與上次測試的結果不一樣，因此該選項可能會改變「嘗試編譯」的結果。對於某一次「嘗試編譯」，該選項最好只用一次；而且僅僅在調試時使用。
    55.  
 
    56.  
 
  56. --debug-output: 將cmake設置爲調試模式。
    57.  
 
  57.  在cmake運行時，打印額外的信息；好比使用message(send_error)調用獲得的棧跟蹤信息。
    58.  
 
    59.  
 
  59. --trace: 將cmake設置爲跟蹤模式。
    60.  
 
  60.  用message(send_error)調用，打印全部調用生成的跟蹤信息，以及這些調用發生的位置。（這句話含義不是很肯定—譯註。）
    61.  
 
    62.  
 
  62. --help-command cmd [file]: 打印單個命令cmd的幫助信息，而後退出。
    63.  
 
  63.  顯示給定的命令的完整的文檔。若是指定了[file]參數，該文檔會寫入該文件，其輸出格式由該文件的後綴名肯定。支持的文件類型有：man page，HTML，DocBook以及純文本。
    64.  
 
    65.  
 
  65. --help-command-list [file]: 列出全部可用命令的清單，而後退出。
    66.  
 
  66.  該選項列出的信息含有全部命令的名字；其中，每一個命令的幫助信息可使用--help-command選項後跟一個命令名字獲得。若是指定了[file]參數，幫助信息會寫到file中，輸出格式依賴於文件名後綴。支持的文件格式包括：man page，HTML，DocBook以及純文本。
    67.  
 
    68.  
 
  68. --help-commands [file]: 打印全部命令的幫助文件，而後退出。
    69.  
 
  69.  顯示全部當前版本的命令的完整文檔。若是指定了[file]參數，幫助信息會寫到file中，輸出格式依賴於文件名後綴。支持的文件格式包括：man page，HTML，DocBook以及純文本。
    70.  
 
    71.  
 
  71. --help-compatcommands [file]: 打印兼容性命令（過期的命令—譯註）的幫助信息。
    72.  
 
  72.  顯示全部關於兼容性命令的完整文檔。若是指定了[file]參數，幫助信息會寫到file中，輸出格式依賴於文件名後綴。支持的文件格式包括：man page，HTML，DocBook以及純文本。
    73.  
 
    74.  
 
  74. --help-module module [file]: 打印某單一模塊的幫助信息，而後退出。
    75.  
 
  75.  打印關於給定模塊的完整信息。若是指定了[file]參數，幫助信息會寫到file中，且輸出格式依賴於文件名後綴。支持的文件格式包括：man page，HTML，DocBook以及純文本。
    76.  
 
    77.  
 
  77. --help-module-list [file]: 列出全部可用模塊名，而後退出。
    78.  
 
  78.  列出的清單包括全部模塊的名字；其中，每一個模塊的幫助信息可使用--help-module選項，後跟模塊名的方式獲得。若是指定了[file]參數，幫助信息會寫到file中，且輸出格式依賴於文件名後綴。支持的文件格式包括：man page，HTML，DocBook以及純文本。
    79.  
 
    80.  
 
  80. --help-modules [file]: 打印全部模塊的幫助信息，而後退出。
    81.  
 
  81.  顯示關於全部模塊的完整文檔。若是指定了[file]參數，幫助信息會寫到file中，且輸出格式依賴於文件名後綴。支持的文件格式包括：man page，HTML，DocBook以及純文本。
    82.  
 
    83.  
 
  83. --help-custom-modules [file]: 打印全部自定義模塊名，而後退出。
    84.  
 
  84.  顯示全部自定義模塊的完整文檔。若是指定了[file]參數，幫助信息會寫到file中，且輸出格式依賴於文件名後綴。支持的文件格式包括：man page，HTML，DocBook以及純文本。
    85.  
 
    86.  
 
  86. --help-policy cmp [file]: 打印單個策略的幫助信息，而後退出。
    87.  
 
  87.  顯示給定的策略的完整文檔。若是指定了[file]參數，幫助信息會寫到file中，且輸出格式依賴於文件名後綴。支持的文件格式包括：man page，HTML，DocBook以及純文本。
    88.  
 
    89.  
 
  89. --help-policies [file]: 打印全部策略的幫助信息，而後退出。
    90.  
 
  90.  顯示全部策略的完整文檔。若是指定了[file]參數，幫助信息會寫到file中，且輸出格式依賴於文件名後綴。支持的文件格式包括：man page，HTML，DocBook以及純文本。
    91.  
 
    92.  
 
  92. --help-property prop [file]: 打印單個屬性的幫助信息，而後退出。
    93.  
 
  93.  顯示指定屬性的完整文檔。若是指定了[file]參數，幫助信息會寫到file中，且輸出格式依賴於文件名後綴。支持的文件格式包括：man page，HTML，DocBook以及純文本。
    94.  
 
    95.  
 
  95. --help-property-list [file]: 列出全部可用的屬性，而後退出。
    96.  
 
  96.  該命令列出的清單包括全部屬性的名字；其中，每一個屬性的幫助信息均可以經過--help-property選項後跟一個屬性名的方式得到。若是指定了[file]參數，幫助信息會寫到file中，且輸出格式依賴於文件名後綴。支持的文件格式包括：man page，HTML，DocBook以及純文本。
    97.  
 
    98.  
 
  98. --help-properties [file]: 打印全部屬性的幫助信息，而後退出。
    99.  
 
  99.  顯示全部屬性的完整文檔。若是指定了[file]參數，幫助信息會寫到file中，且輸出格式依賴於文件名後綴。支持的文件格式包括：man page，HTML，DocBook以及純文本。
    100.  
 
    101.  
 
  101. --help-variable var [file]: 打印單個變量的幫助信息，而後退出。
    102.  
 
  102.  顯示指定變量的完整文檔。若是指定了[file]參數，幫助信息會寫到file中，且輸出格式依賴於文件名後綴。支持的文件格式包括：man page，HTML，DocBook以及純文本。
    103.  
 
    104.  
 
  104. --help-variable-list [file]: 列出文檔中有記錄的變量，而後退出。
    105.  
 
  105.  該命令列出的清單包括全部變量的名字；其中，每一個變量的幫助信息均可以經過--help-variable選項後跟一個變量名的方式得到。若是指定了[file]參數，幫助信息會寫到file中，且輸出格式依賴於文件名後綴。支持的文件格式包括：man page，HTML，DocBook以及純文本。
    106.  
 
    107.  
 
  107. --help-variables [file]: 打印全部變量的幫助信息，而後退出。
    108.  
 
  108.  顯示全部變量的完整幫助文檔。若是指定了[file]參數，幫助信息會寫到file中，且輸出格式依賴於文件名後綴。支持的文件格式包括：man page，HTML，DocBook以及純文本。
    109.  
 
    110.  
 
  110. --copyright [file]: 打印CMake的版權信息，而後退出。
    111.  
 
  111.  若是指定了[file]參數，版權信息會寫到這個文件中。
    112.  
 
    113.  
 
  113. --help: 打印用法信息，而後退出。
    114.  
 
  114.  用法信息描述了基本的命令行界面及其選項。
    115.  
 
    116.  
 
  116. --help-full [file]: 打印完整的幫助信息，而後退出。
    117.  
 
  117.  顯示大多數UNIX man page提供的幫助信息。該選項是爲非UNIX平臺提供的；可是若是man手冊頁沒有安裝，它也能提供便利。若是制定了[file]參數，幫助信息會寫到這個文件中。
    118.  
 
    119.  
 
  119. --help-html [file]: 以HTML格式打印完整的幫助信息，而後退出。
    120.  
 
  120.  CMake的做者使用該選來幫助生成web頁面。若是指定了[file]參數，幫助信息會寫到這個文件中。
    121.  
 
    122.  
 
  122. --help-man [file]: 以UNIX的man手冊頁格式打印完整的幫助信息，而後退出。
    123.  
 
  123.  cmake使用該選生成UNIX的man手冊頁。若是指定了[file]參數，幫助信息會寫到這個文件中。
    124.  
 
    125.  
 
  125. --version [file]: 顯示程序名/版本信息行，而後退出。
    126.  
 
  126.  若是指定了[file]參數，版本信息會寫到這個文件中。
    127.  

 

 

對於CMake的語言要素，好比命令，屬性和變量，幫助命令選項也是頗有規律的，通常是用--help-xxx-list查看全部值的名字，找出感興趣的項，而後用--help-xxx name查看該名字的詳細信息；也能夠用--help-xxxs得到相關語言要素的完整幫助信息。
 

 

生成器
 

在CMake 2.8.3平臺上，CMake支持下列生成器：
 

 

     
 
  • Borland Makefiles: 生成Borland makefile。
    •  
 
  • MSYS Makefiles: 生成MSYS makefile。 
    生成的makefile用use /bin/sh做爲它的shell。在運行CMake的機器上須要安裝msys。
    •  
 
  • MinGW Makefiles: 生成供mingw32-make使用的make file。 
    生成的makefile使用cmd.exe做爲它的shell。生成它們不須要msys或者unix shell。
    •  
 
  • NMake Makefiles: 生成NMake makefile。
    •  
 
  • NMake Makefiles JOM: 生成JOM makefile。
    •  
 
  • Unix Makefiles: 生成標準的UNIX makefile。 
    在構建樹上生成分層的UNIX makefile。任何標準的UNIX風格的make程序均可以經過默認的make目標構建工程。生成的makefile也提供了install目標。
    •  
 
  • Visual Studio 10: 生成Visual Studio 10 工程文件。
    •  
 
  • Visual Studio 10 Win64: 生成Visual Studio 10 Win64 工程文件。
    •  
 
  • Visual Studio 6: 生成Visual Studio 6 工程文件。
    •  
 
  • Visual Studio 7: 生成Visual Studio .NET 2002 工程文件。
    •  
 
  • Visual Studio 7 .NET 2003: 生成Visual Studio .NET 2003工程文件。
    •  
 
  • Visual Studio 8 2005: 生成Visual Studio .NET 2005 工程文件。
    •  
 
  • Visual Studio 8 2005 Win64: 生成Visual Studio .NET 2005 Win64工程文件。
    •  
 
  • Visual Studio 9 2008: 生成Visual Studio 9 2008 工程文件。
    •  
 
  • Visual Studio 9 2008 Win64: 生成Visual Studio 9 2008 Win64工程文件。
    •  
 
  • Watcom WMake: 生成Watcom WMake makefiles。
    •  
 
  • CodeBlocks - MinGW Makefiles: 生成CodeBlock工程文件。 
    在頂層目錄以及每層子目錄下爲CodeBlocks生成工程文件，生成的CMakeList.txt的特色是都包含一個PROJECT()調用。除此以外還會在構建樹上生成一套層次性的makefile。經過默認的make目標，正確的make程序能夠構建這個工程。makefile還提供了install目標。
    •  
 
  • CodeBlocks - NMake Makefiles: 生成CodeBlocks工程文件。 
    在頂層目錄以及每層子目錄下爲CodeBlocks生成工程文件，生成的CMakeList.txt的特色是都包含一個PROJECT()調用。除此以外還會在構建樹上生成一套層次性的makefile。經過默認的make目標，正確的make程序能夠構建這個工程。makefile還提供了install目標。
    •  
 
  • CodeBlocks - Unix Makefiles: 生成CodeBlocks工程文件。 
    在頂層目錄以及每層子目錄下爲CodeBlocks生成工程文件，生成的CMakeList.txt的特色是都包含一個PROJECT()調用。除此以外還會在構建樹上生成一套層次性的makefile。經過默認的make目標，正確的make程序能夠構建這個工程。makefile還提供了install目標。
    •  
 
  • Eclipse CDT4 - MinGW Makefiles: 生成Eclipse CDT 4.0 工程文件。 
    在頂層目錄下爲Eclipse生成工程文件。在運行源碼外構建時，一個鏈接到頂層源碼路徑的資源文件會被建立。除此以外還會在構建樹上生成一套層次性的makefile。經過默認的make目標，正確的make程序能夠構建這個工程。makefile還提供了install目標。
    •  
 
  • Eclipse CDT4 - NMake Makefiles: 生成Eclipse CDT 4.0 工程文件。 
    在頂層目錄下爲Eclipse生成工程文件。在運行源碼外構建時，一個鏈接到頂層源碼路徑的資源文件會被建立。除此以外還會在構建樹上生成一套層次性的makefile。經過默認的make目標，正確的make程序能夠構建這個工程。makefile還提供了install目標。
    •  
 
  • Eclipse CDT4 - Unix Makefiles: 生成Eclipse CDT 4.0 工程文件。 
    在頂層目錄下爲Eclipse生成工程文件。在運行源碼外構建時，一個鏈接到頂層源碼路徑的資源文件會被建立。除此以外還會在構建樹上生成一套層次性的makefile。經過默認的make目標，正確的make程序能夠構建這個工程。makefile還提供了install目標。
    •  

 

 

 

CMake函數
 

CMake手冊的客套話總算說完了，開始進入正題。第一部分是CMake命令。命令就至關於命令行下操做系統提供的各類命令，重要性不言而喻；能夠說，這些命令是CMake構建系統的骨架。CMake 2.8.3共有80條命令，分別是：add_custom_command, add_custom_target, add_definitions, add_dependencies, add_executable, add_library, add_subdirectory, add_test, aux_source_directory, break, build_command, cmake_minimum_required, cmake_policy, configure_file, create_test_sourcelist, define_property, else, elseif, enable_language, enable_testing, endforeach, endfunction, endif, endmacro, endwhile, execute_process, export, file, find_file, find_library, find_package, find_path, find_program, fltk_wrap_ui, foreach, function, get_cmake_property, get_directory_property, get_filename_component, get_property, get_source_file_property, get_target_property, get_test_property, if, include, include_directories, include_external_msproject, include_regular_expression, install, link_directories, list, load_cache, load_command, macro, mark_as_advanced, math, message, option, output_required_files, project, qt_wrap_cpp, qt_wrap_ui, remove_definitions, return, separate_arguments, set, set_directory_properties, set_property, set_source_files_properties, set_target_properties, set_tests_properties, site_name, source_group, string, target_link_libraries, try_compile, try_run, unset, variable_watch, while。這些命令在手冊中是字典序排列的；爲了便於查找，翻譯也按照字典序來組織。可是在翻譯結束後，會對命令進行小結，與你們討論一下這些命令的使用方法和使用時機。
 

 

CMD#1 add_custom_command
 

爲生成的構建系統添加一條自定義的構建規則。 
add_custom_command命令有兩種主要的功能；第一種是爲了生成輸出文件，添加一條自定義命令。
 

 

 

     
 
  1.  add_custom_command(OUTPUT output1 [output2 ...]
    2.  
 
  2.  COMMAND command1 [ARGS] [args1...]
    3.  
 
  3.  [COMMAND command2 [ARGS] [args2...] ...]
    4.  
 
  4.  [MAIN_DEPENDENCY depend]
    5.  
 
  5.  [DEPENDS [depends...]]
    6.  
 
  6.  [IMPLICIT_DEPENDS <lang1> depend1 ...]
    7.  
 
  7.  [WORKING_DIRECTORY dir]
    8.  
 
  8.  [COMMENT comment] [VERBATIM] [APPEND])
    9.  

 

　　這種命令格式定義了一條生成指定的文件（文件組）的生成命令。在相同路徑下建立的目標（CMakeLists.txt文件）——任何自定義命令的輸出都做爲它的源文件——被設置了一條規則：在構建的時候，使用指定的命令來生成這些文件。若是一個輸出文件名是相對路徑，它將被解釋成相對於構建樹路徑的相對路徑，而且與當前源碼路徑是對應的。注意，MAIN_DEPENDENCY徹底是可選的，它用來向visual studio建議在何處中止自定義命令。對於各類類型的makefile而言，這條命令建立了一個格式以下的新目標：
 

 

 

     
 
  1.  OUTPUT: MAIN_DEPENDENCY DEPENDS
    2.  
 
  2. 　　　　COMMAND
    3.  

 

　　若是指定了多於一條的命令，它們會按順序執行。ARGS參數是可選的，它的存在是爲了保持向後兼容，之後會被忽略掉。
 

　　第二種格式爲一個目標——好比一個庫文件或者可執行文件——添加一條自定義命令。這種格式能夠用於目標構建前或構建後的一些操做。這條命令會成爲目標的一部分，而且只有目標被構建時纔會執行。若是目標已經構建了，該目標將不會執行。
 

 

 

     
 
  1.  add_custom_command(TARGET target
    2.  
 
  2.  PRE_BUILD | PRE_LINK | POST_BUILD
    3.  
 
  3.  COMMAND command1 [ARGS] [args1...]
    4.  
 
  4.  [COMMAND command2 [ARGS] [args2...] ...]
    5.  
 
  5.  [WORKING_DIRECTORY dir]
    6.  
 
  6.  [COMMENT comment] [VERBATIM])
    7.  

 

　　這條命令定義了一個與指定目標的構建過程相關的新命令。新命令在什麼時候執行，由下述的選項決定：
 

PRE_BUILD  - 在全部其它的依賴以前執行；
PRE_LINK   - 在全部其它的依賴以後執行；
POST_BUILD - 在目標被構建以後執行；
 

　　注意，只有Visual Studio 7或更高的版本才支持PRE_BUILD。對於其餘的生成器，PRE_BUILD會被當作PRE_LINK來對待。
 

　　若是指定了WORKING_DIRECTORY選項，這條命令會在給定的路徑下執行。若是設置了COMMENT選項，後跟的參數會在構建時、以構建信息的形式、在命令執行以前顯示出來。若是指定了APPEND選項，COMMAND以及DEPENDS選項的值會附加到第一個輸出文件的自定義命令上。在此以前，必須有一次以相同的輸出文件做爲參數的對該命令的調用。在當前版本下，若是指定了APPEND選項，COMMENT, WORKING_DIRECTORY和MAIN_DEPENDENCY選項會被忽略掉，不過將來有可能會用到。
 

　　若是指定了VERBATIM選項，全部該命令的參數將會合適地被轉義，以便構建工具可以以原汁原味的參數去調用那些構建命令。注意，在add_custom_command能看到這些參數以前，CMake語言處理器會對這些參數作一層轉義處理。推薦使用VERBATIM參數，由於它可以保證正確的行爲。當VERBATIM未指定時，CMake的行爲依賴於平臺，由於CMake沒有針對某一種工具的特殊字符采起保護措施。
 

　　若是自定義命令的輸出並非實際的磁盤文件，應該使用SET_SOURCE_FILES_PROPERTIES命令將該輸出的屬性標記爲SYMBOLIC。
 

　　IMPLICIT_DEPENDS選項請求掃描一個輸入文件的隱含依賴關係。給定的語言參數（文中的lang1—譯註）指定了應該使用哪一種編程語言的依賴掃描器。目前爲止，僅支持C和CXX語言掃描器。掃描中發現的依賴文件將會在編譯時添加到自定義命令中。注意，IMPLICIT_DEPENDS選項目前僅僅直至Makefile生成器，其它的生成器會忽略之。
 

　　若是COMMAND選項指定了一個可執行目標（由ADD_EXECUTABLE命令建立的目標），在構建時，它會自動被可執行文件的位置所替換。並且，一個目標級的依賴性將會被添加進去，這樣這個可執行目標將會在全部依賴於該自定義命令的結果的目標以前被構建。不過，任什麼時候候重編譯這個可執行文件，這種特性並不會引入一個會引發自定義命令從新運行的文件級依賴。
 

　　DEPENDS選項指定了該命令依賴的文件。若是依賴的對象是同一目錄（CMakeLists.txt文件）下另一個自定義命令的輸出，CMake會自動將其它自定義命令帶到這個命令中來。若是DEPENDS指定了任何類型的目標（由ADD_*命令建立），一個目標級的依賴性將會被建立，以保證該目標在任何其它目標使用這個自定義命令的輸出以前，該目標已經被建立了。並且，若是該目標是可執行文件或庫文件，一個文件級依賴將會被建立，用來引起自定義命令在目標被重編譯時的從新運行。
 

在Unix Makefile中，這條命令至關於增長了一個依賴關係和一條顯式生成命令。
 

 

CMD#2 add_custom_target
 

add_custom_target 添加一個目標，它沒有輸出；這樣它就老是會被構建。
 

 

 

     
 
  1.  add_custom_target(Name [ALL] [command1 [args1...]]
    2.  
 
  2.  [COMMAND command2 [args2...] ...]
    3.  
 
  3.  [DEPENDS depend depend depend ... ]
    4.  
 
  4.  [WORKING_DIRECTORY dir]
    5.  
 
  5.  [COMMENT comment] [VERBATIM]
    6.  
 
  6.  [SOURCES src1 [src2...]])
    7.  

 

　　用Name選項給定的名字添加一個目標，這個目標會引起給定的那些命令。這個目標沒有輸出文件，而且老是被認爲是過期的，即便那些命令試圖去建立一個與該目標同名的文件。使用ADD_CUSTOM_COMMAND命令能夠生成一個帶有依賴性的文件。默認狀況下，沒有目標會依賴於自定義目標。使用ADD_DEPENDENCIES命令能夠添加依賴於該目標或者被該目標依賴的目標。若是指定了ALL選項，這代表這個目標應該被添加到默認的構建目標中，這樣它每次都會被構建（命令的名字不能是ALL）。命令和選項是可選的；若是它們沒有被指定，將會產生一個空目標。若是設定了WORKING_DIRECTORY參數，該命令會在它指定的路徑下執行。若是指定了COMMENT選項，後跟的參數將會在構件的時候，在命令執行以前，被顯示出來。DEPENDS選項後面列出來的依賴目標能夠引用add_custom_command命令在相同路徑下（CMakeLists.txt）生成的輸出和文件。
 

　　若是指定了VERBATIM選項，全部傳遞到該命令的選項將會被合適地轉義；這樣，該命令調用的構建工具會接收到未經改變的參數。注意，CMake語言處理器會在add_custom_target命令在看到這些參數以前對它們進行一層轉義。推薦使用該參數，由於它保證了正確的行爲。當未指定該參數時，轉義的行爲依賴於平臺，由於CMake沒有針對於特定工具中特殊字符的保護措施。
 

　　SOURCES選項指定了會被包含到自定義目標中的附加的源文件。指定的源文件將會被添加到IDE的工程文件中，方便在沒有構建規則的狀況下可以編輯。
 

 

CMD#3 add_definitions
 

爲源文件的編譯添加由-D引入的define flag。
 

 

 

     
 
  1.  add_definitions(-DFOO -DBAR ...)
    2.  

 

　　在編譯器的命令行上，爲當前路徑以及下層路徑的源文件加入一些define flag。這個命令能夠用來引入任何flag，可是它的原意是用來引入預處理器的定義。那些以-D或/D開頭的、看起來像預處理器定義的flag，會被自動加到當前路徑的COMPILE_DEFINITIONS屬性中。爲了後向兼容，非簡單值（non-trival，指的是什麼？——譯註）的定義會被留在flags組（flags set）裏，而不會被轉換。關於在特定的域以及配置中增長預處理器的定義，參考路徑、目標以及源文件的COMPILE_DEFINITIONS屬性來獲取更多的細節。
 

 

CMD#4 add_dependencies
 

爲頂層目標引入一個依賴關係。
 

 

 

     
 
  1.  add_dependencies(target-name depend-target1
    2.  
 
  2.  depend-target2 ...)
    3.  

 

　　讓一個頂層目標依賴於其餘的頂層目標。一個頂層目標是由命令ADD_EXECUTABLE，ADD_LIBRARY，或者ADD_CUSTOM_TARGET產生的目標。爲這些命令的輸出引入依賴性能夠保證某個目標在其餘的目標以前被構建。查看ADD_CUSTOM_TARGET和ADD_CUSTOM_COMMAND命令的DEPENDS選項，能夠了解如何根據自定義規則引入文件級的依賴性。查看SET_SOURCE_FILES_PROPERTIES命令的OBJECT_DEPENDS選項，能夠了解如何爲目標文件引入文件級的依賴性。
 

 

CMD#5 add_executable
 

使用給定的源文件，爲工程引入一個可執行文件。
 

 

 

     
 
  1.  add_executable(<name> [WIN32] [MACOSX_BUNDLE]
    2.  
 
  2.  [EXCLUDE_FROM_ALL]
    3.  
 
  3.  source1 source2 ... sourceN)
    4.  

 

　　引入一個名爲<name>的可執行目標，該目標會由調用該命令時在源文件列表中指定的源文件來構建。<name>對應於邏輯目標名字，而且在工程範圍內必須是全局惟一的。被構建的可執行目標的實際文件名將根據具體的本地平臺建立出來（好比<name>.exe或者僅僅是<name>）。
 

　　默認狀況下，可執行文件將會在構建樹的路徑下被建立，對應於該命令被調用的源文件樹的路徑。若是要改變這個位置，查看RUNTIME_OUTPUT_DIRECTORY目標屬性的相關文檔。若是要改變最終文件名的<name>部分，查看OUTPUT_NAME目標屬性的相關文檔。
 

　　若是指定了MACOSX_BUNDLE選項，對應的屬性會附加在建立的目標上。查看MACOSX_BUNDLE目標屬性的文檔能夠找到更多的細節。
 

　　若是指定了EXCLUDE_FROM_ALL選項，對應的屬性將會設置在被建立的目標上。查看EXCLUDE_FROM_ALL目標屬性的文檔能夠找到更多的細節。
 

　　使用下述格式，add_executable命令也能夠用來建立導入的（IMPORTED）可執行目標：
 

 

 

     
 
  1. 　　add_executable(<name> IMPORTED)
    2.  

 

　　一個導入的可執行目標引用了一個位於工程以外的可執行文件。該格式不會生成構建這個目標的規則。該目標名字的做用域在它被建立的路徑以及底層路徑有效。它能夠像在該工程內的其餘任意目標同樣被引用。導入可執行文件爲相似於add_custom_command之類的命令引用它提供了便利。
 

　　關於導入的可執行文件的細節能夠經過設置以IMPORTED_開頭的屬性來指定。這類屬性中最重要的是IMPORTED_LOCATION（以及它對應於具體配置的版本IMPORTED_LOCATION_<CONFIG>）；該屬性指定了執行文件主文件在磁盤上的位置。查看IMPORTED_*屬性的文檔來得到更多信息。 
　 
　 
　　
 

 

CMD#6 add_library
 

使用指定的源文件向工程中添加一個庫。
 

 

 

     
 
  1.  add_library(<name> [STATIC | SHARED | MODULE]
    2.  
 
  2.  [EXCLUDE_FROM_ALL]
    3.  
 
  3.  source1 source2 ... sourceN)
    4.  

 

　　添加一個名爲<name>的庫文件，該庫文件將會根據調用的命令裏列出的源文件來建立。<name>對應於邏輯目標名稱，並且在一個工程的全局域內必須是惟一的。待構建的庫文件的實際文件名根據對應平臺的命名約定來構造（好比lib<name>.a或者<name>.lib）。指定STATIC，SHARED，或者MODULE參數用來指定要建立的庫的類型。STATIC庫是目標文件的歸檔文件，在連接其它目標的時候使用。SHARED庫會被動態連接，在運行時被加載。MODULE庫是不會被連接到其它目標中的插件，可是可能會在運行時使用dlopen-系列的函數動態連接。若是沒有類型被顯式指定，這個選項將會根據變量BUILD_SHARED_LIBS的當前值是否爲真決定是STATIC仍是SHARED。
 

　　默認狀態下，庫文件將會在於源文件目錄樹的構建目錄樹的位置被建立，該命令也會在這裏被調用。查閱ARCHIVE_OUTPUT_DIRECTORY，LIBRARY_OUTPUT_DIRECTORY，和RUNTIME_OUTPUT_DIRECTORY這三個目標屬性的文檔來改變這一位置。查閱OUTPUT_NAME目標屬性的文檔來改變最終文件名的<name>部分。
 

　　若是指定了EXCLUDE_FROM_ALL屬性，對應的一些屬性會在目標被建立時被設置。查閱EXCLUDE_FROM_ALL的文檔來獲取該屬性的細節。
 

　　使用下述格式，add_library命令也能夠用來建立導入的庫目標：
 

 

 

     
 
  1.  add_library(<name> <SHARED|STATIC|MODULE|UNKNOWN> IMPORTED)
    2.  

 

　　導入的庫目標是引用了在工程外的一個庫文件的目標。沒有生成構建這個庫的規則。這個目標名字的做用域在它被建立的路徑及如下有效。他能夠向任何在該工程內構建的目標同樣被引用。導入庫爲相似於target_link_libraries命令中引用它提供了便利。關於導入庫細節能夠經過指定那些以IMPORTED_的屬性設置來指定。其中最重要的屬性是IMPORTED_LOCATION（以及它的具體配置版本，IMPORTED_LOCATION_<CONFIG>），它指定了主庫文件在磁盤上的位置。查閱IMPORTED_*屬性的文檔獲取更多的信息。
 

 

CMD#7 add_subdirectory 爲構建添加一個子路徑。
 

 

 

     
 
  1.  add_subdirectory(source_dir [binary_dir] 
    2.  
 
  2.  [EXCLUDE_FROM_ALL])
    3.  

 

　　這條命令的做用是爲構建添加一個子路徑。source_dir選項指定了CMakeLists.txt源文件和代碼文件的位置。若是source_dir是一個相對路徑，那麼source_dir選項會被解釋爲相對於當前的目錄，可是它也能夠是一個絕對路徑。binary_dir選項指定了輸出文件的路徑。若是binary_dir是相對路徑，它將會被解釋爲相對於當前輸出路徑，可是它也能夠是一個絕對路徑。若是沒有指定binary_dir，binary_dir的值將會是沒有作任何相對路徑展開的source_dir，這也是一般的用法。在source_dir指定路徑下的CMakeLists.txt將會在當前輸入文件的處理過程執行到該命令以前，當即被CMake處理。
 

　　若是指定了EXCLUDE_FROM_ALL選項，在子路徑下的目標默認不會被包含到父路徑的ALL目標裏，而且也會被排除在IDE工程文件以外。用戶必須顯式構建在子路徑下的目標，好比一些示範性的例子工程就是這樣。典型地，子路徑應該包含它本身的project()命令調用，這樣會在子路徑下產生一份完整的構建系統（好比VS IDE的solution文件）。注意，目標間的依賴性要高於這種排除行爲。若是一個被父工程構建的目標依賴於在這個子路徑下的目標，被依賴的目標會被包含到父工程的構建系統中，以知足依賴性的要求。
 

 

CMD#8 add_test
 

以指定的參數爲工程添加一個測試。
 

 

 

     
 
  1.  add_test(testname Exename arg1 arg2 ... )
    2.  

 

　　若是已經運行過了ENABLE_TESTING命令，這個命令將爲當前路徑添加一個測試目標。若是ENABLE_TESTING尚未運行過，該命令啥事都不作。測試是由測試子系統運行的，它會以指定的參數執行Exename文件。Exename或者是由該工程構建的可執行文件，也能夠是系統上自帶的任意可執行文件（好比tclsh）。該測試會在CMakeList.txt文件的當前工做路徑下運行，這個路徑與二進制樹上的路相對應。
 

 

 

     
 
  1.  add_test(NAME <name> [CONFIGURATIONS [Debug|Release|...]]
    2.  
 
  2.  COMMAND <command> [arg1 [arg2 ...]])
    3.  

 

　　若是COMMAND選項指定了一個可執行目標（用add_executable建立），它會自動被在構建時建立的可執行文件所替換。若是指定了CONFIGURATIONS選項，那麼該測試只有在列出的某一個配置下才會運行。
 

　　在COMMAND選項後的參數可使用「生成器表達式」，它的語法是$<...>。這些表達式會在構建系統生成期間，以及構建配置的專有信息的產生期間被評估。合法的表達式是：
 

$<CONFIGURATION>          = 配置名稱
    $<TARGET_FILE:tgt>        = 主要的二進制文件(.exe, .so.1.2, .a)
    $<TARGET_LINKER_FILE:tgt> = 用於連接的文件(.a, .lib, .so)
    $<TARGET_SONAME_FILE:tgt> = 帶有.so.的文件(.so.3)
 

　　其中，"tgt"是目標的名稱。目標文件表達式TARGET_FILE生成了一個完整的路徑，可是它的_DIR和_NAME版本能夠生成目錄以及文件名部分：
 

$<TARGET_FILE_DIR:tgt>/$<TARGET_FILE_NAME:tgt>
$<TARGET_LINKER_FILE_DIR:tgt>/$<TARGET_LINKER_FILE_NAME:tgt>
$<TARGET_SONAME_FILE_DIR:tgt>/$<TARGET_SONAME_FILE_NAME:tgt>
 

　　用例：
 

 

 

     
 
  1.  add_test(NAME mytest
    2.  
 
  2.  COMMAND testDriver --config $<CONFIGURATION>
    3.  
 
  3.  --exe $<TARGET_FILE:myexe>)
    4.  

 

　　這段代碼建立了一個名爲mytest的測試，它執行的命令是testDriver工具，傳遞的參數包括配置名，以及由目標生成的可執行文件myexe的完整路徑。
 

 

CMD#9 aux_source_directory
 

查找在某個路徑下的全部源文件。
 

 

 

     
 
  1.  aux_source_directory(<dir> <variable>)
    2.  

 

　　蒐集全部在指定路徑下的源文件的文件名，將輸出結果列表儲存在指定的<variable>變量中。該命令主要用在那些使用顯式模板實例化的工程上。模板實例化文件能夠存儲在Templates子目錄下，而後可使用這條命令自動收集起來；這樣能夠避免手工羅列全部的實例。
 

　　使用該命令來避免爲一個庫或可執行目標寫源文件的清單，是很是具備吸引力的。可是若是該命令貌似能夠發揮做用，那麼CMake就不須要生成一個感知新的源文件什麼時候被加進來的構建系統了（也就是說，新文件的加入，並不會致使CMakeLists.txt過期，從而不能引發CMake從新運行。——譯註）。正常狀況下，生成的構建系統可以感知它什麼時候須要從新運行CMake，由於須要修改CMakeLists.txt來引入一個新的源文件。當源文件僅僅是加到了該路徑下，可是沒有修改這個CMakeLists.txt文件，使用者只能手動從新運行CMake來產生一個包含這個新文件的構建系統。
 

 

CMD#10 break
 

從一個包圍該命令的foreach或或while循環中跳出。
 

 

 

     
 
  1.  break()
    2.  

 

　　從包圍它的foreach循環或while循環中跳出。 
　　 
　　
 

 

CMD#11 build_command
 

獲取構建該工程的命令行。
 

 

 

     
 
  1.  build_command(<variable>
    2.  
 
  2.  [CONFIGURATION <config>]
    3.  
 
  3.  [PROJECT_NAME <projname>]
    4.  
 
  4.  [TARGET <target>])
    5.  

 

　　把給定的變量<variable>設置成一個字符串，其中包含使用由變量CMAKE_GENERATOR肯定的項目構建工具，去構建某一個工程的某一個目標配置的命令行。
 

　　對於多配置生成器，若是忽略CONFIGURATION選項，CMake將會選擇一個合理的默認值；而對於單配置生成器，該選項會被忽略。
 

　　若是PROJECT_NAME選項被忽略，獲得的命令行用來構建當前構建樹上的頂層工程。
 

　　若是TARGET選項被忽略，獲得的命令行能夠用來構建全部目標，比較高效的用法是構建目標all或者ALL_BUILD。
 

 

 

     
 
  1.  build_command(<cachevariable> <makecommand>)
    2.  

 

　　不推薦使用以上的這種格式，但對於後相兼容仍是有用的。只要能夠，就要使用第一種格式。
 

　　這種格式將變量<cachevariable>設置爲一個字符串，其中包含從構建樹的根目錄，用<makecommand>指定的構建工具構建這個工程的命令。<makecommand>應該是指向msdev，devenv，nmake，make或者是一種最終用戶指定的構建工具的完整路徑。
 

 

CMD#12 cmake_minimum_required
 

設置一個工程所須要的最低CMake版本。
 

 

 

     
 
  1.  cmake_minimum_required(VERSION major[.minor[.patch[.tweak]]]
    2.  
 
  2.  [FATAL_ERROR])
    3.  

 

　　若是CMake的當前版本低於指定的版本，它會中止處理工程文件，並報告錯誤。當指定的版本高於2.4時，它會隱含調用：
 

 

 

     
 
  1.  cmake_policy(VERSION major[.minor[.patch[.tweak]]])
    2.  

 

　　從而將cmale的策略版本級別設置爲指定的版本。當指定的版本是2.4或更低時，這條命令隱含調用：
 

 

 

     
 
  1.  cmake_policy(VERSION 2.4)
    2.  

 

　　這將會啓用對於CMake 2.4及更低版本的兼容性。
 

　　FATAL_ERROR選項是能夠接受的，可是CMake 2.6及更高的版本會忽略它。若是它被指定，那麼CMake 2.4及更低版本將會以錯誤了結而非僅僅給出個警告。
 

 

CMD#13 cmake_policy
 

管理CMake的策略設置。 
　　隨着CMake的演變，有時爲了搞定bug或改善現有特點的實現方法，改變現有的行爲是必須的。CMake的策略機制是在新的CMake版本帶來行爲上的改變時，用來幫助保持現有項目的構建的一種設計。每一個新的策略（行爲改變）被賦予一個CMP<NNNN>格式的識別符，其中<NNNN>是一個整數索引。每一個策略相關的文檔都會描述「舊行爲」和「新行爲」，以及引入該策略的緣由。工程能夠設置各類策略來選擇指望的行爲。當CMake須要瞭解要用哪一種行爲的時候，它會檢查由工程指定的一種設置。若是沒有可用的設置，工程假定使用「舊行爲」，而且會給出警告要求你設置工程的策略。
 

　　cmake_policy是用來設置「新行爲」或「舊行爲」的命令。若是支持單獨設置策略，咱們鼓勵各項目根據CMake的版原本設置策略。
 

 

 

     
 
  1.  cmake_policy(VERSION major.minor[.patch[.tweak]])
    2.  

 

　　上述命令指定當前的CMakeLists.txt是爲給定版本的CMake書寫的。全部在指定的版本或更早的版本中引入的策略會被設置爲使用「新行爲」。全部在指定的版本以後引入的策略將會變爲無效（unset）。該命令有效地爲一個指定的CMake版本請求優先採用的行爲，而且告知更新的CMake版本給出關於它們新策略的警告。命令中指定的策略版本必須至少是2.4，不然命令會報告一個錯誤。爲了獲得支持早於2.4版本的兼容性特性，查閱策略CMP0001的相關文檔。
 

 

 

     
 
  1. 　　cmake_policy(SET CMP<NNNN> NEW)
    2.  
 
  2. 　　cmake_policy(SET CMP<NNNN> OLD)
    3.  

 

　　對於某種給定的策略，該命令要求CMake使用新的或者舊的行爲。對於一個指定的策略，那些依賴於舊行爲的工程，經過設置策略的狀態爲OLD，能夠禁止策略的警告。或者，用戶可讓工程採用新行爲，而且設置策略的狀態爲NEW。
 

 

 

     
 
  1.  cmake_policy(GET CMP<NNNN> <variable>)
    2.  

 

　　該命令檢查一個給定的策略是否設置爲舊行爲或新行爲。若是策略被設置，輸出的變量值會是「OLD」或「NEW」，不然爲空。
 

　　CMake將策略設置保存在一個棧結構中，所以，cmake_policy命令產生的改變僅僅影響在棧頂端的元素。在策略棧中的一個新條目由各子路徑自動管理，以此保護它的父路徑及同層路徑的策略設置。CMake也管理經過include()和find_package()命令加載的腳本中新加入的條目，除非調用時指定了NO_POLICY_SCOPE選項（另外可參考CMP0011）。cmake_policy命令提供了一種管理策略棧中自定義條目的接口： 
　　
 

 

 

     
 
  1.  cmake_policy(PUSH)
    2.  
 
  2.  cmake_policy(POP)
    3.  

 

　　每一個PUSH必須有一個配對的POP來去掉撤銷改變。這對於臨時改變策略設置比較有用。
 

　　函數和宏會在它們被建立的時候記錄策略設置，而且在它們被調用的時候使用記錄前的策略。若是函數或者宏實現設置了策略，這個變化會經過調用者(caller)一直上傳，自動傳遞到嵌套的最近的策略棧條目。 
　　
 

 

CMD#14 configure_file
 

將一份文件拷貝到另外一個位置並修改它的內容。
 

 

 

     
 
  1.  configure_file(<input> <output>
    2.  
 
  2.  [COPYONLY] [ESCAPE_QUOTES] [@ONLY])
    3.  

 

　　將文件<input>拷貝到<output>而後替換文件內容中引用到的變量值。若是<input>是相對路徑，它被評估的基礎路徑是當前源碼路徑。<input>必須是一個文件，而不是個路徑。若是<output>是一個相對路徑，它被評估的基礎路徑是當前二進制文件路徑。若是<output>是一個已有的路徑，那麼輸入文件將會以它原來的名字放到那個路徑下。
 

　　該命令替換掉在輸入文件中，以${VAR}格式或@VAR@格式引用的任意變量，如同它們的值是由CMake肯定的同樣。 若是一個變量還未定義，它會被替換爲空。若是指定了COPYONLY選項，那麼變量就不會展開。若是指定了ESCAPE_QUOTES選項，那麼全部被替換的變量將會按照C語言的規則被轉義。該文件將會以CMake變量的當前值被配置。若是指定了@ONLY選項，只有@VAR@格式的變量會被替換而${VAR}格式的變量則會被忽略。這對於配置使用${VAR}格式的腳本文件比較有用。任何相似於#cmakedefine VAR的定義語句將會被替換爲#define VAR或者/* #undef VAR */，視CMake中對VAR變量的設置而定。任何相似於#cmakedefine 01 VAR的定義語句將會被替換爲#define VAR 1或#define VAR 0，視VAR被評估爲TRUE或FALSE而定。
 

（configure_file的做用是讓普通文件也能使用CMake中的變量。——譯註）
 

 

CMD#15 create_test_sourcelist
 

爲構建測試程序建立一個測試驅動器和源碼列表。
 

 

 

     
 
  1.  create_test_sourcelist(sourceListName driverName
    2.  
 
  2.  test1 test2 test3
    3.  
 
  3.  EXTRA_INCLUDE include.h
    4.  
 
  4.  FUNCTION function)
    5.  

 

　　測試驅動器是一個將不少小的測試代碼鏈接爲一個單一的可執行文件的程序。這在爲了縮減總的需用空間而用不少大的庫文件去構建靜態可執行文件的時候，特別有用。構建測試驅動所須要的源文件列表會在變量sourceListName中。DriverName變量是測試驅動器的名字。其它的參數還包括一個測試源代碼文件的清單，中間能夠用分號隔開。每一個測試源碼文件中應該有一個與去掉擴展名的文件名同名的函數（好比foo.cxx 文件裏應該有int foo(int, char*[]);）（和main的函數簽名同樣——譯註）。DriverName能夠在命令行中按名字調用這些測試中的每個。若是指定了EXTRA_INCLUDE，那麼它後面的參數（即include.h——譯註）會被包含到生成的文件裏。若是指定了FUNCTION選項，那麼它後面的參數（即function——譯註）會被認爲是一個函數名，傳遞給它的參數是一個指向argc的指針和argv。這個選項能夠用來爲每一個測試函數添加額外的命令行參數處理過程。CMake變量CMAKE_TESTDRIVER_BEFORE_TESTMAIN用來設置在調用測試的main函數以前調用的代碼。
 

 

CMD#16 define_property
 

定義並描述（Document）自定義屬性。
 

 

 

     
 
  1.  　　define_property(<GLOBAL | DIRECTORY | TARGET | SOURCE |
    2.  
 
  2.  TEST | VARIABLE | CACHED_VARIABLE>
    3.  
 
  3.  PROPERTY <name> [INHERITED]
    4.  
 
  4.  BRIEF_DOCS <brief-doc> [docs...]
    5.  
 
  5.  FULL_DOCS <full-doc> [docs...])
    6.  

 

　　在一個域(域（scope)）中定義一個能夠用set_property和get_property命令訪問的屬性。這個命令對於把文檔和能夠經過get_property命令獲得的屬性名稱關聯起來很是有用。第一個參數肯定了這個屬性可使用的範圍。它必須是下列值中的一個：
 

GLOBAL    = 與全局命名空間相關聯
DIRECTORY = 與某一個目錄相關聯
TARGET    = 與一個目標相關聯
SOURCE    = 與一個源文件相關聯
TEST      = 與一個以add_test命名的測試相關聯
VARIABLE  = 描述（document）一個CMake語言變量
CACHED_VARIABLE = 描述（document）一個CMake語言緩存變量
 

　　注意，與set_property和get_property不相同，不須要給出實際的做用域；只有做用域的類型纔是重要的。PROPERTY選項必須有，它後面緊跟要定義的屬性名。若是指定了INHERITED選項，那麼若是get_property命令所請求的屬性在該做用域中未設置，它會沿着鏈條向更高的做用域去搜索。DIRECTORY域向上是GLOBAL。TARGET，SOURCE和TEST向上是DIRECTORY。
 

　　BRIEF_DOCS和FULL_DOCS選項後面的參數是和屬性相關聯的字符串，分別做爲變量的簡單描述和完整描述。在使用get_property命令時，對應的選項能夠獲取這些描述信息。 
　 
　 
　　
 

 

CMD#17 else
 

開始一個if語句塊的else部分。
 

 

 

     
 
  1.  else(expression)
    2.  

 

參見if命令。 
　 
　 
　
 

 

CMD#18 elseif
 

開始 if 塊的 elseif 部分。
 

 

 

     
 
  1.  elseif(expression)
    2.  

 

參見if命令。 
　 
　 
　
 

 

CMD#19 enable_language
 

支持某種語言（CXX/C/Fortran/等）
 

 

 

     
 
  1.  enable_language(languageName [OPTIONAL] )
    2.  

 

　　該命令打開了CMake對參數中指定的語言的支持。這與project命令相同，可是不會建立任何project命令會產生的額外變量。能夠選用的語言的類型有CXX，C，Fortran等。若是指定了OPTIONAL選項，用CMAKE_<languageName>_COMPILER_WORKS變量來判斷該語言是否被成功支持。
 

 

CMD#20 enable_testing
 

打開當前及如下目錄中的測試功能。
 

 

 

     
 
  1. 　　enable_testing()
    2.  

 

　　爲當前及其下級目錄打開測試功能。也可參見add_test命令。注意，ctest須要在構建跟目錄下找到一個測試文件。所以，這個命令應該在源文件目錄的根目錄下。
 

 

CMD#21 endforeach
 

結束foreach語句塊中的一系列命令。
 

 

 

     
 
  1.  endforeach(expression)
    2.  

 

　　參見FOREACH命令。 
　　
 

 

CMD#22 endfunction
 

結束一個function語句塊中的一系列命令。
 

 

 

     
 
  1.  endfunction(expression)
    2.  

 

　　參見function命令。 
　　
 

 

CMD#23 endif
 

結束一個if語句塊中的一系列命令。
 

 

 

     
 
  1.  endif(expression)
    2.  

 

　　參見if命令。 
　　
 

 

CMD#24 endmacro
 

結束一個macro語句塊中的一系列命令。
 

 

 

     
 
  1.  endmacro(expression)
    2.  

 

　　參見macro命令。 
　　
 

 

 

CMD#25: endwhile 
結束一個while語句塊中的一系列命令。
 

 

 

     
 
  1.  endwhile(expression)
    2.  

 

　　參見while命令。 
　　
 

 

CMD#26 execute_process
 

執行一個或更多個子進程。
 

 

 

     
 
  1.  execute_process(COMMAND <cmd1> [args1...]]
    2.  
 
  2.  [COMMAND <cmd2> [args2...] [...]]
    3.  
 
  3.  [WORKING_DIRECTORY <directory>]
    4.  
 
  4.  [TIMEOUT <seconds>]
    5.  
 
  5.  [RESULT_VARIABLE <variable>]
    6.  
 
  6.  [OUTPUT_VARIABLE <variable>]
    7.  
 
  7.  [ERROR_VARIABLE <variable>]
    8.  
 
  8.  [INPUT_FILE <file>]
    9.  
 
  9.  [OUTPUT_FILE <file>]
    10.  
 
  10.  [ERROR_FILE <file>]
    11.  
 
  11.  [OUTPUT_QUIET]
    12.  
 
  12.  [ERROR_QUIET]
    13.  
 
  13.  [OUTPUT_STRIP_TRAILING_WHITESPACE]
    14.  
 
  14.  [ERROR_STRIP_TRAILING_WHITESPACE])
    15.  

 

　　運行一條或多條命令，使得前一條命令的標準輸出以管道的方式成爲下一條命令的標準輸入。全部進程公用一個單獨的標準錯誤管道。若是指定了WORKING_DIRECTORY選項，後面的路徑選項將會設置爲子進程的當前工做路徑。若是指定了TIMEOUT選項，若是子進程沒有在指定的秒數（容許分數）裏完成，子進程會自動終止。若是指定了RESULT_VARIABLE選項，該變量將保存爲正在運行的進程的結果；它能夠是最後一個子進程的整數返回代碼，也能夠是一個描述錯誤狀態的字符串。若是指定了OUTPUT_VARIABLE或者ERROR_VARIABLE，後面的變量將會被分別設置爲標準輸出和標準錯誤管道的值。若是兩個管道都是用了相同的變量，它們的輸出將會按產生的順序被合併。若是指定了INPUT_FILE，OUTPUT_FILE或 ERROR_FILE選項，其後的文件將會分別被附加到第一個進程的標準輸入、最後一個進程的標準輸出，或者全部進程的標準錯誤管道上。若是指定了OUTPUT_QUIET後者ERROR_QUIET選項，那麼標準輸出或標準錯誤的結果將會被靜靜的忽略掉。若是爲同一個管道指定了多於一個的OUTPUT_*或ERROR_* 選項，優先級是沒有指定的。若是沒有指定OUTPUT_*或者ERROR_*選項，輸出將會與CMake進程自身對應的管道共享。
 

　　execute_process命令是exec_program命令的一個較新的功能更增強大的版本。可是爲了兼容性的緣由，舊的exec_program命令還會繼續保留。
 

 

CMD#27 export
 

從構建樹中導出目標供外部使用。
 

 

 

     
 
  1.  export(TARGETS [target1 [target2 [...]]] [NAMESPACE <namespace>]
    2.  
 
  2.  [APPEND] FILE <filename>)
    3.  

 

　　建立一個名爲<filename>的文件，它能夠被外部工程包含進去，從而外部工程能夠從當前工程的構建樹中導入目標。這對於交叉編譯那些能夠運行在宿主平臺的的utility可執行文件，而後將它們導入到另一個編譯成目標平臺代碼的工程中的情形，特別有用。若是指定了NAMESPACE選項，<namespace>字符串將會被擴展到輸出文件中的全部目標的名字中。若是指定了APPEND選項，生成的代碼將會續接在文件以後，而不是覆蓋它。若是一個庫目標被包含在export中，可是鏈接成它的目標沒有被包含，行爲沒有指定。
 

　　由該命令建立的文件是與指定的構建樹一致的，而且絕對不該該被安裝。要從一個安裝樹上導出目標，參見install(EXPORT)命令。
 

 

 

     
 
  1.  export(PACKAGE <name>)
    2.  

 

　　在CMake的用戶包註冊表中，爲<name>包(package)存儲當前的構建目錄。這將有助於依賴於它的工程從當前工程的構建樹中查找並使用包而不須要用戶的介入。注意，該命令在包註冊表中建立的條目，僅僅在與跟構建樹一塊兒運行的包配置文件(<name>Config.cmake)一塊兒使用時纔會起做用。 
　　
 

 

CMD#28 file
 

文件操做命令
 

 

 

     
 
  1.  file(WRITE filename "message to write"... )
    2.  
 
    3.  
 
  3.  file(APPEND filename "message to write"... )
    4.  
 
    5.  
 
  5.  file(READ filename variable [LIMIT numBytes] [OFFSET offset] [HEX])
    6.  
 
    7.  
 
  7.  file(STRINGS filename variable [LIMIT_COUNT num]
    8.  
 
  8.  [LIMIT_INPUT numBytes] [LIMIT_OUTPUT numBytes]
    9.  
 
  9.  [LENGTH_MINIMUM numBytes] [LENGTH_MAXIMUM numBytes]
    10.  
 
  10.  [NEWLINE_CONSUME] [REGEX regex]
    11.  
 
  11.  [NO_HEX_CONVERSION])
    12.  
 
    13.  
 
  13.  file(GLOB variable [RELATIVE path] [globbing expressions]...)
    14.  
 
    15.  
 
  15.  file(GLOB_RECURSE variable [RELATIVE path] 
    16.  
 
  16.  [FOLLOW_SYMLINKS] [globbing expressions]...)
    17.  
 
    18.  
 
  18.  file(RENAME <oldname> <newname>)
    19.  
 
    20.  
 
  20.  file(REMOVE [file1 ...])
    21.  
 
    22.  
 
  22.  file(REMOVE_RECURSE [file1 ...])
    23.  
 
    24.  
 
  24.  file(MAKE_DIRECTORY [directory1 directory2 ...])
    25.  
 
    26.  
 
  26.  file(RELATIVE_PATH variable directory file)
    27.  
 
    28.  
 
  28.  file(TO_CMAKE_PATH path result)
    29.  
 
    30.  
 
  30.  file(TO_NATIVE_PATH path result)
    31.  
 
    32.  
 
  32.  file(DOWNLOAD url file [TIMEOUT timeout] [STATUS status] [LOG log]
    33.  
 
  33.  [EXPECTED_MD5 sum] [SHOW_PROGRESS])
    34.  

 

　　WRITE選項將會寫一條消息到名爲filename的文件中。若是文件已經存在，該命令會覆蓋已有的文件；若是文件不存在，它將建立該文件。
 

　　APPEND選項和WRITE選項同樣，將會寫一條消息到名爲filename的文件中，只是該消息會附加到文件末尾。
 

　　READ選項將會讀一個文件中的內容並將其存儲在變量裏。讀文件的位置從offset開始，最多讀numBytes個字節。若是指定了HEX參數，二進制代碼將會轉換爲十六進制表達方式，並存儲在變量裏。
 

　　STRINGS將會從一個文件中將一個ASCII字符串的list解析出來，而後存儲在variable變量中。文件中的二進制數據會被忽略。回車換行符會被忽略。它也能夠用在Intel的Hex和Motorola的S-記錄文件；讀取它們時，它們會被自動轉換爲二進制格式。可使用NO_HEX_CONVERSION選項禁止這項功能。LIMIT_COUNT選項設定了返回的字符串的最大數量。LIMIT_INPUT設置了從輸入文件中讀取的最大字節數。LIMIT_OUTPUT設置了在輸出變量中存儲的最大字節數。LENGTH_MINIMUM設置了要返回的字符串的最小長度；小於該長度的字符串會被忽略。LENGTH_MAXIMUM設置了返回字符串的最大長度；更長的字符串會被分割成不長於最大長度的字符串。NEWLINE_CONSUME選項容許新行被包含到字符串中，而不是終止它們。REGEX選項指定了一個待返回的字符串必須知足的正則表達式。典型的使用方式是：
 

 

 

     
 
  1.  file(STRINGS myfile.txt myfile)
    2.  

 

該命令在變量myfile中存儲了一個list，該list中每一個項是輸入文件中的一行文本。 
　　GLOB選項將會爲全部匹配查詢表達式的文件生成一個文件list，並將該list存儲進變量variable裏。文件名查詢表達式與正則表達式相似，只不過更加簡單。若是爲一個表達式指定了RELATIVE標誌，返回的結果將會是相對於給定路徑的相對路徑。文件名查詢表達式的例子有：
 

*.cxx      - 匹配全部擴展名爲cxx的文件。
*.vt?      - 匹配全部擴展名是vta,...,vtz的文件。
f[3-5].txt - 匹配文件f3.txt, f4.txt, f5.txt。
 

　　GLOB_RECURSE選項將會生成一個相似於一般的GLOB選項的list，只是它會尋訪全部那些匹配目錄的子路徑並同時匹配查詢表達式的文件。做爲符號連接的子路徑只有在給定FOLLOW_SYMLINKS選項或者cmake策略CMP0009被設置爲NEW時，纔會被尋訪到。參見cmake --help-policy CMP0009 查詢跟多有用的信息。
 

使用遞歸查詢的例子有：
 

/dir/*.py  - 匹配全部在/dir及其子目錄下的python文件。

    MAKE_DIRECTORY選項將會建立指定的目錄，若是它們的父目錄不存在時，一樣也會建立。（相似於mkdir命令——譯註）

    RENAME選項對同一個文件系統下的一個文件或目錄重命名。（相似於mv命令——譯註）

    REMOVE選項將會刪除指定的文件，包括在子路徑下的文件。（相似於rm命令——譯註）

    REMOVE_RECURSE選項會刪除給定的文件以及目錄，包括非空目錄。（相似於rm -r 命令——譯註）

    RELATIVE_PATH選項會肯定從direcroty參數到指定文件的相對路徑。

    TO_CMAKE_PATH選項會把path轉換爲一個以unix的 / 開頭的cmake風格的路徑。輸入能夠是一個單一的路徑，也能夠是一個系統路徑，好比"$ENV{PATH}"。注意，在調用TO_CMAKE_PATH的ENV周圍的雙引號只能有一個參數(Note the double quotes around the ENV call TO_CMAKE_PATH only takes one argument. 原文如此。quotes和後面的takes讓人後糾結，這句話翻譯可能有誤。歡迎指正——譯註)。

    TO_NATIVE_PATH選項與TO_CMAKE_PATH選項很類似，可是它會把cmake風格的路徑轉換爲本地路徑風格：windows下用\，而unix下用/。

    DOWNLOAD 將給定的URL下載到指定的文件中。若是指定了LOG var選項，下載日誌將會被輸出到var中。若是指定了STATUS var選項，下載操做的狀態會被輸出到var中。該狀態返回值是一個長度爲2的list。list的第一個元素是操做的數字返回值，第二個返回值是錯誤的字符串值。錯誤信息若是是數字0，操做中沒有發生錯誤。若是指定了TIMEOUT time選項，在time秒以後，操做會超時退出；time應該是整數。若是指定了EXPECTED_MD5 sum選項，下載操做會認證下載的文件的實際MD5和是否與指望值匹配。若是不匹配，操做將返回一個錯誤。若是指定了SHOW_PROGRESS選項，進度信息會以狀態信息的形式被打印出來，直到操做完成。
 

　　file命令還提供了COPY和INSTALL兩種格式：
 

 

 

     
 
  1.  file(<COPY|INSTALL> files... DESTINATION <dir>
    2.  
 
  2.  [FILE_PERMISSIONS permissions...]
    3.  
 
  3.  [DIRECTORY_PERMISSIONS permissions...]
    4.  
 
  4.  [NO_SOURCE_PERMISSIONS] [USE_SOURCE_PERMISSIONS]
    5.  
 
  5.  [FILES_MATCHING]
    6.  
 
  6.  [[PATTERN <pattern> | REGEX <regex>]
    7.  
 
  7.  [EXCLUDE] [PERMISSIONS permissions...]] [...])
    8.  

 

　　COPY版本把文件、目錄以及符號鏈接拷貝到一個目標文件夾。相對輸入路徑的評估是基於當前的源代碼目錄進行的，相對目標路徑的評估是基於當前的構建目錄進行的。複製過程將保留輸入文件的時間戳；而且若是目標路徑處存在同名同時間戳的文件，複製命令會把它優化掉。賦值過程將保留輸入文件的訪問權限，除非顯式指定權限或指定NO_SOURCE_PERMISSIONS選項（默認是USE_SOURCE_PERMISSIONS）。參見install(DIRECTORY)命令中關於權限(permissions)，PATTERN，REGEX和EXCLUDE選項的文檔。
 

　　INSTALL版本與COPY版本只有十分微小的差異：它會打印狀態信息，而且默認使用NO_SOURCE_PERMISSIONS選項。install命令生成的安裝腳本使用這個版本（它會使用一些沒有在文檔中涉及的內部使用的選項。） 
　　 
　　
 

 

CMD#29 find_file
 

查找一個文件的完整路徑。
 

 

 

     
 
  1.  find_file(<VAR> name1 [path1 path2 ...])
    2.  

 

　　這是該命令的精簡格式，對於大多數場合它都足夠了。它與命令find_file(<VAR> name1 [PATHS path1 path2 ...])是等價的。
 

 

 

     
 
  1.  find_file(
    2.  
 
  2.  <VAR>
    3.  
 
  3.  name | NAMES name1 [name2 ...]
    4.  
 
  4.  [HINTS path1 [path2 ... ENV var]]
    5.  
 
  5.  [PATHS path1 [path2 ... ENV var]]
    6.  
 
  6.  [PATH_SUFFIXES suffix1 [suffix2 ...]]
    7.  
 
  7.  [DOC "cache documentation string"]
    8.  
 
  8.  [NO_DEFAULT_PATH]
    9.  
 
  9.  [NO_CMAKE_ENVIRONMENT_PATH]
    10.  
 
  10.  [NO_CMAKE_PATH]
    11.  
 
  11.  [NO_SYSTEM_ENVIRONMENT_PATH]
    12.  
 
  12.  [NO_CMAKE_SYSTEM_PATH]
    13.  
 
  13.  [CMAKE_FIND_ROOT_PATH_BOTH |
    14.  
 
  14.  ONLY_CMAKE_FIND_ROOT_PATH |
    15.  
 
  15.  NO_CMAKE_FIND_ROOT_PATH]
    16.  
 
  16.  )
    17.  

 

　　這條命令用來查找指定文件的完整路徑。一個名字是<VAR>的緩存條目（參見CMakeCache.txt的介紹——譯註）變量會被建立，用來存儲該命令的結果。若是發現了文件的一個完整路徑，該結果會被存儲到該變量裏而且搜索過程不會再重複，除非該變量被清除。若是什麼都沒發現，搜索的結果將會是<VAR>-NOTFOUND；而且在下一次以相同的變量調用find_file時，該搜索會從新嘗試。被搜索的文件的文件名由NAMES選項後的名字列表指定。附加的其餘搜索位置能夠在PATHS選項以後指定。若是ENV var在HINTS或PATHS段中出現，環境變量var將會被讀取而後被轉換爲一個系統級環境變量，並存儲在一個cmake風格的路徑list中。好比，使用ENV PATH將會將系統的path變量列出來。在DOC以後的變量將會用於cache中的文檔字符串(documentation string)。PATH_SUFFIXES指定了在每一個搜索路徑下的須要搜索的子路徑。
 

　　若是指定了NO_DEFAULT_PATH選項，那麼在搜索時不會附加其它路徑。若是沒有指定NO_DEFAULT_PATH選項，搜索過程以下：
 

　　一、在cmake特有的cache變量中指定的搜索路徑搜索。這些路徑用於在命令行裏用-DVAR=value被設置。若是使用了NO_CMAKE_PATH選項，該路徑會被跳過。（此句翻譯可能有誤——譯註。）搜索路徑還包括：
 

對於每一個在CMAKE_PREFIX_PATH中的路徑<prefix>，<prefix>/include  
變量：CMAKE_INCLUDE_PATH
變量：CMAKE_FRAMEWORK_PATH
 

　　二、在cmake特定的環境變量中指定的搜索路徑搜索。該路徑會在用戶的shell配置中被設置。若是指定了NO_CMAKE_ENVIRONMENT_PATH選項，該路徑會被跳過。搜索路徑還包括：
 

對於每一個在CMAKE_PREFIX_PATH中的路徑<prefix>，<prefix>/include  
變量：CMAKE_INCLUDE_PATH
變量：CMAKE_FRAMEWORK_PATH
 

　　三、由HINTS選項指定的搜索路徑。這些路徑是由系統內省(introspection)時計算出來的路徑，好比已經發現的其餘項的位置所提供的痕跡。硬編碼的參考路徑應該使用PATHS選項指定。（HINTS與PATHS有何不一樣？比後者的優先級高？有疑問。——譯註）
 

　　四、搜索標準的系統環境變量。若是指定NO_SYSTEM_ENVIRONMENT_PATH選項，搜索路徑將跳過其後的參數。搜索路徑包括環境變量PATH個INCLUDE。
 

　　五、查找在當前系統的平臺文件中定義的cmake變量。若是指定了NO_CMAKE_SYSTEM_PATH選項，該路徑會被跳過。其餘的搜索路徑還包括：
 

對於每一個在CMAKE_PREFIX_PATH中的路徑<prefix>，<prefix>/include  
變量：CMAKE_SYSTEM_INCLUDE_PATH
變量：CMAKE_SYSTEM_FRAMEWORK_PATH
 

　　六、搜索由PATHS選項指定的路徑或者在命令的簡寫版本中指定的路徑。這通常是一些硬編碼的參考路徑。在Darwin後者支持OS X框架的系統上，cmake變量CMAKE_FIND_FRAMWORK能夠設置爲空或者下述值之一：
 

"FIRST"  - 在標準庫或者頭文件以前先查找框架。對於Darwin系統，這是默認的。
"LAST"   - 在標準庫或頭文件以後再查找框架。
"ONLY"   - 只查找框架。
"NEVER" - 從不查找框架。
 

　　在Darwin或者支持OS X Application Bundles的系統上，cmake變量CMAKE_FIND_APPBUNDLE能夠被設置爲空，或者下列值之一：
 

"FIRST"  - 在標準程序以前查找application bundles，這也是Darwin系統的默認選項。
"LAST"   - 在標準程序以後查找application bundlesTry。
"ONLY"   - 只查找application bundles。
"NEVER" - 從不查找application bundles。
 

　　CMake的變量CMAKE_FIND_ROOT_PATH指定了一個或多個在全部其它搜索路徑以前的搜索路徑。該選項頗有效地將給定位置下的整個搜索路徑的最優先路徑進行了從新指定。默認狀況下，它是空的。當交叉編譯一個指向目標環境下的根目錄中的目標時，CMake也會搜索那些路徑；該變量這時顯得很是有用。默認狀況下，首先會搜索在CMAKE_FIND_ROOT_PATH變量中列出的路徑，而後纔是非根路徑。設置CMAKE_FIND_ROOT_PATH_MODE_INCLUDE變量能夠調整該默認行爲。該行爲能夠在每次調用時被手動覆蓋。經過使用CMAKE_FIND_ROOT_PATH_BOTH變量，搜索順序將會是上述的那樣。若是使用了NO_CMAKE_FIND_ROOT_PATH變量，那麼CMAKE_FIND_ROOT_PATH將不會被用到。若是使用了ONLY_CMAKE_FIND_ROOT_PATH變量，那麼只有CMAKE_FIND_ROOT_PATH中的路徑（即re-rooted目錄——譯註）會被搜索。
 

　　通常狀況下，默認的搜索順序是從最具體的路徑到最不具體的路徑。只要用NO_*選項屢次調用該命令，工程就能夠覆蓋該順序。
 

 

 

     
 
  1.  find_file(<VAR> NAMES name PATHS paths... NO_DEFAULT_PATH)
    2.  
 
  2.  find_file(<VAR> NAMES name)
    3.  

 

　　只要這些調用中的一個成功了，返回變量就會被設置並存儲在cache中；而後該命令就不會再繼續查找了。 
　　
 

 

CMD#30 find_library
 

查找一個庫文件
 

 

 

     
 
  1.  find_library(<VAR> name1 [path1 path2 ...])
    2.  

 

　　這是該命令的簡寫版本，在大多數場合下都已經夠用了。它與命令find_library(<VAR> name1 [PATHS path1 path2 ...])等價。
 

 

 

     
 
  1.  find_library(
    2.  
 
  2.  <VAR>
    3.  
 
  3.  name | NAMES name1 [name2 ...]
    4.  
 
  4.  [HINTS path1 [path2 ... ENV var]]
    5.  
 
  5.  [PATHS path1 [path2 ... ENV var]]
    6.  
 
  6.  [PATH_SUFFIXES suffix1 [suffix2 ...]]
    7.  
 
  7.  [DOC "cache documentation string"]
    8.  
 
  8.  [NO_DEFAULT_PATH]
    9.  
 
  9.  [NO_CMAKE_ENVIRONMENT_PATH]
    10.  
 
  10.  [NO_CMAKE_PATH]
    11.  
 
  11.  [NO_SYSTEM_ENVIRONMENT_PATH]
    12.  
 
  12.  [NO_CMAKE_SYSTEM_PATH]
    13.  
 
  13.  [CMAKE_FIND_ROOT_PATH_BOTH |
    14.  
 
  14.  ONLY_CMAKE_FIND_ROOT_PATH |
    15.  
 
  15.  NO_CMAKE_FIND_ROOT_PATH]
    16.  
 
  16.  )
    17.  

 

　　該命令用來查找一個庫文件。一個名爲<VAR>的cache條目會被建立來存儲該命令的結果。若是找到了該庫文件，那麼結果會存儲在該變量裏，而且搜索過程將再也不重複，除非該變量被清空。若是沒有找到，結果變量將會是<VAR>-NOTFOUND，而且在下次使用相同變量調用find_library命令時，搜索過程會再次嘗試。在NAMES參數後列出的文件名是要被搜索的庫名。附加的搜索位置在PATHS參數後指定。若是再HINTS或者PATHS字段中設置了ENV變量var，環境變量var將會被讀取並從系統環境變量轉換爲一個cmake風格的路徑list。例如，指定ENV PATH是獲取系統path變量並將其轉換爲cmake的list的一種方式。在DOC以後的參數用來做爲cache中的註釋字符串。PATH_SUFFIXES選項指定了每一個搜索路徑下待搜索的子路徑。
 

　　若是指定了NO_DEFAULT_PATH選項，那麼搜索的過程當中不會有其餘的附加路徑。若是沒有指定該選項，搜索過程以下：
 

　　一、搜索cmake特有的cache變量指定的路徑。這些變量是在用cmake命令行時，經過-DVAR=value指定的變量。若是指定了NO_CMAKE_PATH選項，這些路徑會被跳過。搜索的路徑還包括：
 

對於每一個在CMAKE_PREFIX_PATH中的<prefix>，路徑<prefix>/lib 
CMAKE_LIBRARY_PATH
CMAKE_FRAMEWORK_PATH
 

　　二、搜索cmake特有的環境變量指定的路徑。這些變量是用戶的shell配置中設置的變量。若是指定了NO_CMAKE_ENVIRONMENT_PATH選項，這些路徑會被跳過。搜索的路徑還包括：
 

對於每一個在CMAKE_PREFIX_PATH中的<prefix>，路徑<prefix>/lib 
CMAKE_LIBRARY_PATH
CMAKE_FRAMEWORK_PATH
 

　　三、搜索由HINTS選項指定的路徑。這些路徑是系統內省(introspection)估算出的路徑，好比由另外一個已經發現的庫文件的地址提供的參考信息。硬編碼的推薦路徑應該經過PATHS選項指定。
 

　　四、查找標準的系統環境變量。若是指定了NO_SYSTEM_ENVIRONMENT_PATH選項，這些路徑會被跳過。搜索的路徑還包括：
 

PATH
LIB
 

　　五、查找在爲當前系統的平臺文件中定義的cmake變量。若是指定了NO_CMAKE_SYSTEM_PATH選項，該路徑會被跳過。搜索的路徑還包括：
 

對於每一個在CMAKE_SYSTEM_PREFIX_PATH中的<prefix>，路徑<prefix>/lib 
CMAKE_SYSTEM_LIBRARY_PATH
CMAKE_SYSTEM_FRAMEWORK_PATH
 

　　六、搜索PATHS選項或者精簡版命令指定的路徑。這些一般是硬編碼的推薦搜索路徑。
 

　　在Darwin或者支持OS X 框架的系統上，cmake變量CMAKE_FIND_FRAMEWORK能夠用來設置爲空，或者下述值之一：
 

FIRST"  - 在標準庫或頭文件以前查找框架。在Darwin系統上這是默認選項。
"LAST"   - 在標準庫或頭文件以後查找框架。
"ONLY"   - 僅僅查找框架。
NEVER" - 從不查找框架。
 

　　在Darwin或者支持OS X Application Bundles的系統，cmake變量CMAKE_FIND_APPBUNDLE能夠被設置爲空或者下面這些值中的一個：
 

"FIRST"  - 在標準庫或頭文件以前查找application bundles。在Darwin系統上這是默認選項。
"LAST"   - 在標準庫或頭文件以後查找application bundles。
"ONLY"   - 僅僅查找application bundles。
"NEVER" - 從不查找application bundles。
 

　　CMake變量CMAKE_FIND_ROOT_PATH指定了一個或者多個優先於其餘搜索路徑的搜索路徑。該變量可以有效地從新定位在給定位置下進行搜索的根路徑。該變量默認爲空。當使用交叉編譯時，該變量十分有用：用該變量指向目標環境的根目錄，而後CMake將會在那裏查找。默認狀況下，在CMAKE_FIND_ROOT_PATH中列出的路徑會首先被搜索，而後是「非根」路徑。該默認規則能夠經過設置CMAKE_FIND_ROOT_PATH_MODE_LIBRARY作出調整。在每次調用該命令以前，均可以經過設置這個變量來手動覆蓋默認行爲。若是使用了NO_CMAKE_FIND_ROOT_PATH變量，那麼只有重定位的路徑會被搜索。
 

　　默認的搜索順序的設計邏輯是按照使用時從最具體到最不具體。經過屢次調用find_library命令以及NO_*選項，能夠覆蓋工程的這個默認順序：
 

 

 

     
 
  1.  find_library(<VAR> NAMES name PATHS paths... NO_DEFAULT_PATH)
    2.  
 
  2.  find_library(<VAR> NAMES name)
    3.  

 

　　只要這些調用中的一個成功返回，結果變量就會被設置而且被存儲到cache中；這樣隨後的調用都不會再行搜索。若是那找到的庫是一個框架，VAR將會被設置爲指向框架<完整路徑>/A.framework 的完整路徑。當一個指向框架的完整路徑被用做一個庫文件，CMake將使用-framework A，以及-F<完整路徑>這兩個選項將框架鏈接到目標上。 
　　 
　　 
　　
 

 

CMD#31 find_package
 

爲外部工程加載設置。
 

 

 

     
 
  1.  find_package(<package> [version] [EXACT] [QUIET]
    2.  
 
  2.  [[REQUIRED|COMPONENTS] [components...]]
    3.  
 
  3.  [NO_POLICY_SCOPE])
    4.  

 

　　查找並加載外來工程的設置。該命令會設置<package>_FOUND變量，用來指示要找的包是否被找到了。若是這個包被找到了，與它相關的信息能夠經過包自身記載的變量中獲得。QUIET選項將會禁掉包沒有被發現時的警告信息。REQUIRED選項表示若是報沒有找到的話，cmake的過程會終止，並輸出警告信息。在REQUIRED選項以後，或者若是沒有指定REQUIRED選項可是指定了COMPONENTS選項，在它們的後面能夠列出一些與包相關的部件清單(components list)。[version]參數須要一個版本號，它是正在查找的包應該兼容的版本號（格式是major[.minor[.patch[.tweak]]]）。EXACT選項要求該版本號必須精確匹配。若是在find-module內部對該命令的遞歸調用沒有給定[version]參數，那麼[version]和EXACT選項會自動地從外部調用前向繼承。對版本的支持目前只存在於包和包之間（詳見下文）。
 

　　用戶代碼整體上應該使用上述的簡單調用格式查詢須要的包。本命令文檔的剩餘部分則詳述了find_package的完整命令格式以及具體的查詢過程。指望經過該命令查找並提供包的項目維護人員，咱們鼓勵你能繼續讀下去。
 

　　該命令在搜索包時有兩種模式：「模塊」模式和「配置」模式。當該命令是經過上述的精簡格式調用的時候，合用的就是模塊模式。在該模式下，CMake搜索全部名爲Find<package>.cmake的文件，這些文件的路徑由變量由安裝CMake時指定的CMAKE_MODULE_PATH變量指定。若是查找到了該文件，它會被CMake讀取並被處理。該模式對查找包，檢查版本以及生成任何別的必須信息負責。許多查找模塊（find-module）僅僅提供了有限的，甚至根本就沒有對版本化的支持；具體信息查看該模塊的文檔。若是沒有找到任何模塊，該命令會進入配置模式繼續執行。
 

　　完整的配置模式下的命令格式是：
 

 

 

     
 
  1.  find_package(<package> [version] [EXACT] [QUIET]
    2.  
 
  2.  [[REQUIRED|COMPONENTS] [components...]] [NO_MODULE]
    3.  
 
  3.  [NO_POLICY_SCOPE]
    4.  
 
  4.  [NAMES name1 [name2 ...]]
    5.  
 
  5.  [CONFIGS config1 [config2 ...]]
    6.  
 
  6.  [HINTS path1 [path2 ... ]]
    7.  
 
  7.  [PATHS path1 [path2 ... ]]
    8.  
 
  8.  [PATH_SUFFIXES suffix1 [suffix2 ...]]
    9.  
 
  9.  [NO_DEFAULT_PATH]
    10.  
 
  10.  [NO_CMAKE_ENVIRONMENT_PATH]
    11.  
 
  11.  [NO_CMAKE_PATH]
    12.  
 
  12.  [NO_SYSTEM_ENVIRONMENT_PATH]
    13.  
 
  13.  [NO_CMAKE_PACKAGE_REGISTRY]
    14.  
 
  14.  [NO_CMAKE_BUILDS_PATH]
    15.  
 
  15.  [NO_CMAKE_SYSTEM_PATH]
    16.  
 
  16.  [CMAKE_FIND_ROOT_PATH_BOTH |
    17.  
 
  17.  ONLY_CMAKE_FIND_ROOT_PATH |
    18.  
 
  18.  NO_CMAKE_FIND_ROOT_PATH])
    19.  

 

　　NO_MODULE能夠用來明確地跳過模塊模式。它也隱含指定了不使用在精簡格式中使用的那些選項。
 

　　配置模式試圖查找一個由待查找的包提供的配置文件的位置。包含該文件的路徑會被存儲在一個名爲<package>_DIR的cache條目裏。默認狀況下，該命令搜索名爲<package>的包。若是指定了NAMES選項，那麼其後的names參數會取代<package>的角色。該命令會爲每一個在names中的name搜索名爲<name>Config.cmake或者<name全小寫>-config.cmake的文件。經過使用CONFIGS選項能夠改變可能的配置文件的名字。如下描述搜索的過程。若是找到了配置文件，它將會被CMake讀取並處理。因爲該文件是由包自身提供的，它已經知道包中內容的位置。配置文件的完整地址存儲在cmake的變量<package>_CONFIG中。
 

　　全部CMake要處理的配置文件將會搜索該包的安裝信息，而且將該安裝匹配的適當版本號(appropriate version)存儲在cmake變量<package>_CONSIDERED_CONFIGS中，與之相關的版本號(associated version)將被存儲在<package>_CONSIDERED_VERSIONS中。
 

　　若是沒有找到包配置文件，CMake將會生成一個錯誤描述文件，用來描述該問題——除非指定了QUIET選項。若是指定了REQUIRED選項，而且沒有找到該包，將會報致命錯誤，而後配置步驟終止執行。若是設置了<package>_DIR變量被設置了，可是它沒有包含配置文件信息，那麼CMake將會直接無視它，而後從新開始查找。
 

　　若是給定了[version]參數，那麼配置模式僅僅會查找那些在命令中請求的版本（格式是major[.minor[.patch[.tweak]]]）與包請求的版本互相兼容的那些版本的包。若是指定了EXACT選項，一個包只有在它請求的版本與[version]提供的版本精確匹配時才能被找到。CMake不會對版本數的含義作任何的轉換。包版本號由包自帶的版本文件來檢查。對於一個備選的包配置文件<config-file>.cmake，對應的版本文件的位置緊挨着它，而且名字或者是<config-file>-version.cmake或者是<config-file>Version.cmake。若是沒有這個版本文件，那麼配置文件就會認爲不兼容任何請求的版本。當找到一個版本文件以後，它會被加載而後用來檢查（find_package）請求的版本號。版本文件在一個下述變量被定義的嵌套域中被加載：
 

PACKAGE_FIND_NAME          = <package>名字。
PACKAGE_FIND_VERSION       = 請求的完整版本字符串
PACKAGE_FIND_VERSION_MAJOR = 若是被請求了，那麼它是major版本號，不然是0。
PACKAGE_FIND_VERSION_MINOR = 若是被請求了，那麼它是minor版本號，不然是0。
PACKAGE_FIND_VERSION_PATCH = 若是被請求了，那麼它是patch版本號，不然是0。
PACKAGE_FIND_VERSION_TWEAK = 若是被請求了，那麼它是tweak版本號，不然是0。
PACKAGE_FIND_VERSION_COUNT = 版本號包含幾部分，0到4。
 

　　版本文件會檢查自身是否知足請求的版本號，而後設置了下面這些變量：
 

PACKAGE_VERSION            = 提供的完整的版本字符串。
PACKAGE_VERSION_EXACT      = 若是版本號精確匹配，返回true。
PACKAGE_VERSION_COMPATIBLE = 若是版本號相兼容，返回true。
PACKAGE_VERSION_UNSUITABLE = 若是不適合任何版本，返回true。
 

　　下面這些變量將會被find_package命令檢查，用以肯定配置文件是否提供了可接受的版本。在find_package命令返回後，這些變量就不可用了。若是版本可接受，下述的變量會被設置：
 

<package>_VERSION       = 提供的完整的版本字符串。
<package>_VERSION_MAJOR = 若是被請求了，那麼它是major版本號，不然是0。
<package>_VERSION_MINOR = 若是被請求了，那麼它是minor版本號，不然是0。
<package>_VERSION_PATCH = 若是被請求了，那麼它是patch版本號，不然是0。
<package>_VERSION_TWEAK = 若是被請求了，那麼它是tweak版本號，不然是0。
<package>_VERSION_COUNT = 版本號包含幾部分，0到4。
 

而後，對應的包配置文件纔會被加載。當多個包配置文件均可用時，而且這些包的版本文件都與請求的版本兼容，選擇哪一個包將會是不肯定的。不該該假設cmake會選擇最高版本或者是最低版本。（以上的若干段是對find_package中版本匹配步驟的描述，並不須要用戶干預——譯註。）
 

　　配置模式提供了一種高級接口和搜索步驟的接口。這些被提供的接口的大部分是爲了完整性的要求，以及在模塊模式下，包被find-module加載時供內部使用。大多數用戶僅僅應該調用：
 

 

 

     
 
  1.  find_package(<package> [major[.minor]] [EXACT] [REQUIRED|QUIET])
    2.  

 

來查找包。鼓勵那些須要提供CMake包配置文件的包維護人員應該命名這些文件並安裝它們，這樣下述的整個過程將會找到它們而不須要使用附加的選項。
 

　　CMake爲包構造了一組可能的安裝前綴。在每一個前綴下，若干個目錄會被搜索，用來查找配置文件。下述的表格展現了待搜索的路徑。每一個條目都是專門爲Windows(W)，UNIX(U)或者Apple(A)約定的安裝樹指定的。
 

<prefix>/                                               (W)
<prefix>/(cmake|CMake)/                                 (W)
<prefix>/<name>*/                                       (W)
<prefix>/<name>*/(cmake|CMake)/                         (W)
<prefix>/(share|lib)/cmake/<name>*/                     (U)
<prefix>/(share|lib)/<name>*/                           (U)
<prefix>/(share|lib)/<name>*/(cmake|CMake)/             (U)
 

　　在支持OS X平臺和Application Bundles的系統上，包含配置文件的框架或者bundles會在下述的路徑中被搜索：
 

<prefix>/<name>.framework/Resources/                    (A)
<prefix>/<name>.framework/Resources/CMake/              (A)
<prefix>/<name>.framework/Versions/*/Resources/         (A)
<prefix>/<name>.framework/Versions/*/Resources/CMake/   (A)
<prefix>/<name>.app/Contents/Resources/                 (A)
<prefix>/<name>.app/Contents/Resources/CMake/           (A)
 

　　在全部上述狀況下，<name>是區分大小寫的，而且對應於在<package>或者由NAMES給定的任何一個名字。
 

　　這些路徑集用來與那些在各自的安裝樹上提供了配置文件的工程協做。上述路徑中被標記爲(W)的是專門爲Windows上的安裝設置的，其中的<prefix>部分多是一個應用程序的頂層安裝路徑。那些被標記爲(U)的是專門爲UNIX平臺上的安裝設置的，其中的<prefix>被多個包共用。這僅僅是個約定，所以，全部(W)和(U)路徑在全部平臺上都仍然會被搜索。那些被標記爲(A)的路徑是專門爲Apple平臺上的安裝設置的。CMake變量CMAKE_FIND_FRAMEWORK和CMAKE_FIND_APPBUNDLE肯定了偏好的順序，以下所示：
 

　　安裝前綴是經過如下步驟被構建出來的。若是指定了NO_DEFAULT_PATH選項，全部NO_*選項都會被激活。
 

　　一、搜索在cmake特有的cache變量中指定的搜索路徑。這些變量是爲了在命令行中用-DVAR=value選項指定而設計的。經過指定NO_CMAKE_PATH選項能夠跳過該搜索路徑。搜索路徑還包括：
 

CMAKE_PREFIX_PATH
CMAKE_FRAMEWORK_PATH
CMAKE_APPBUNDLE_PATH
 

　　二、搜索cmake特有的環境變量。這些變量是爲了在用戶的shell配置中進行配置而設計的。經過指定NO_CMAKE_ENVIRONMENT_PATH選項能夠跳過該路徑。搜索的路徑包括：
 

<package>_DIR
CMAKE_PREFIX_PATH
CMAKE_FRAMEWORK_PATH
CMAKE_APPBUNDLE_PATH
 

　　三、搜索HINTS選項指定的路徑。這些路徑應該是由操做系統內省時計算產生的，好比由其它已經找到的項的位置而提供的線索。硬編碼的參考路徑應該在PATHS選項中指定。
 

　　四、搜索標準的系統環境變量。若是指定了NO_SYSTEM_ENVIRONMENT_PATH選項，這些路徑會被跳過。以/bin或/sbin結尾的路徑條目會被自動轉換爲它們的父路徑。搜索的路徑包括：
 

PATH
 

　　五、搜索在CMake GUI中最新配置過的工程的構建樹。能夠經過設置NO_CMAKE_BUILDS_PATH選項來跳過這些路徑。這是爲了在用戶正在依次構建多個相互依賴的工程時而準備的。
 

　　六、搜索存儲在CMake用戶包註冊表中的路徑。經過設置NO_CMAKE_PACKAGE_REGISTRY選項能夠跳過這些路徑。當CMake用export(PACKAGE<name>)配置一個工程時，這些路徑會被存儲在註冊表中。參見export(PACKAGE)命令的文檔閱讀更多細節。
 

　　七、搜索在當前系統的平臺文件中定義的cmake變量。能夠用NO_CMAKE_SYSTEM_PATH選項跳過這些路徑。
 

CMAKE_SYSTEM_PREFIX_PATH
CMAKE_SYSTEM_FRAMEWORK_PATH
CMAKE_SYSTEM_APPBUNDLE_PATH
 

　　八、搜索由PATHS選項指定的路徑。這些路徑通常是硬編碼的參考路徑。
 

　　在Darwin或者支持OS X 框架的系統上，cmake變量CMAKE_FIND_FRAMEWORK能夠用來設置爲空，或者下述值之一：
 

"FIRST"  - 在標準庫或頭文件以前查找框架。在Darwin系統上這是默認選項。
"LAST"   - 在標準庫或頭文件以後查找框架。
"ONLY"   - 僅僅查找框架。
"NEVER" - 從不查找框架。
 

　　在Darwin或者支持OS X Application Bundles的系統，cmake變量CMAKE_FIND_APPBUNDLE能夠被設置爲空或者下面這些值中的一個：
 

"FIRST"  - 在標準庫或頭文件以前查找application bundles。在Darwin系統上這是默認選項。
"LAST"   - 在標準庫或頭文件以後查找application bundles。
"ONLY"   - 僅僅查找application bundles。
"NEVER" - 從不查找application bundles。
 

　　CMake變量CMAKE_FIND_ROOT_PATH指定了一個或者多個優先於其餘搜索路徑的搜索路徑。該變量可以有效地從新定位在給定位置下進行搜索的根路徑。該變量默認爲空。當使用交叉編譯時，該變量十分有用：用該變量指向目標環境的根目錄，而後CMake將會在那裏查找。默認狀況下，在CMAKE_FIND_ROOT_PATH中列出的路徑會首先被搜索，而後是「非根」路徑。該默認規則能夠經過設置CMAKE_FIND_ROOT_PATH_MODE_LIBRARY作出調整。在每次調用該命令以前，均可以經過設置這個變量來手動覆蓋默認行爲。若是使用了NO_CMAKE_FIND_ROOT_PATH變量，那麼只有重定位的路徑會被搜索。
 

　　默認的搜索順序的設計邏輯是按照使用時從最具體到最不具體。經過屢次調用find_library命令以及NO_*選項，能夠覆蓋工程的這個默認順序：
 

 

 

     
 
  1.  find_library(<VAR> NAMES name PATHS paths... NO_DEFAULT_PATH)
    2.  
 
  2.  find_library(<VAR> NAMES name)
    3.  

 

　　只要這些調用中的一個成功返回，結果變量就會被設置而且被存儲到cache中；這樣隨後的調用都不會再行搜索。若是那找到的庫是一個框架，VAR將會被設置爲指向框架<完整路徑>/A.framework 的完整路徑。當一個指向框架的完整路徑被用做一個庫文件，CMake將使用-framework A，以及-F<完整路徑>這兩個選項將框架鏈接到目標上。
 

　　參見cmake_policy()命令的文檔中關於NO_POLICY_SCOPE選項討論。 
　　 
　　 
　　
 

 

CMD#32 find_path
 

搜索包含某個文件的路徑
 

 

 

     
 
  1.  find_path(<VAR> name1 [path1 path2 ...])
    2.  

 

　　在多數狀況下，使用上述的精簡命令格式就足夠了。它與命令find_path(<VAR> name1 [PATHS path1 path2 ...])等價。
 

 

 

     
 
  1.  find_path(
    2.  
 
  2.  <VAR>
    3.  
 
  3.  name | NAMES name1 [name2 ...]
    4.  
 
  4.  [HINTS path1 [path2 ... ENV var]]
    5.  
 
  5.  [PATHS path1 [path2 ... ENV var]]
    6.  
 
  6.  [PATH_SUFFIXES suffix1 [suffix2 ...]]
    7.  
 
  7.  [DOC "cache documentation string"]
    8.  
 
  8.  [NO_DEFAULT_PATH]
    9.  
 
  9.  [NO_CMAKE_ENVIRONMENT_PATH]
    10.  
 
  10.  [NO_CMAKE_PATH]
    11.  
 
  11.  [NO_SYSTEM_ENVIRONMENT_PATH]
    12.  
 
  12.  [NO_CMAKE_SYSTEM_PATH]
    13.  
 
  13.  [CMAKE_FIND_ROOT_PATH_BOTH |
    14.  
 
  14.  ONLY_CMAKE_FIND_ROOT_PATH |
    15.  
 
  15.  NO_CMAKE_FIND_ROOT_PATH]
    16.  
 
  16.  )
    17.  

 

　　該命令用於給定名字文件所在的路徑。一條名爲<VAR>的cache條目會被建立，並存儲該命令的執行結果。若是在某個路徑下發現了該文件，該結果會被存儲到該變量中；除非該變量被清除，該次搜索不會繼續進行。若是沒有找到，存儲的結果將會是<VAR>-NOTFOUND，而且當下一次以相同的變量名調用find_path命令時，該命令會再一次嘗試搜索該文件。須要搜索的文件名經過在NAMES選項後面的列出來的參數來肯定。附加的搜索位置能夠在PATHS選項以後指定。若是在PATHS或者HINTS命令中還指定了ENV var選項，環境變量var將會被讀取並從一個系統環境變量轉換爲一個cmake風格的路徑list。好比，ENV PATH是列出系統path變量的一種方法。參數DOC將用來做爲該變量在cache中的註釋。PATH_SUFFIXES指定了在每一個搜索路徑下的附加子路徑。
 

　　若是指定了NO_DEFAULT_PATH選項，那麼沒有其它附加的路徑會被加到搜索過程當中。若是並未指定NO_DEFAULT_PATH選項，搜索的過程以下：
 

　　一、搜索cmake專有的cache變量中的路徑。這種用法是爲了在命令行中用選項-DVAR=value指定搜索路徑。若是指定了NO_CMAKE_PATH選項，該路徑會被跳過。搜索路徑還包括：
 

對於每一個在CMAKE_PREFIX_PATH中的<prefix>/，路徑<prefix>/include
CMAKE_INCLUDE_PATH
CMAKE_FRAMEWORK_PATH
 

　　二、搜索cmake專有的環境變量中指定的路徑。這種用法是爲了在用戶的shell配置中設置指定的搜索路徑。若是指定了NO_CMAKE_ENVIRONMENT_PATH選項，該路徑會被跳過。搜索路徑還包括：
 

對於每一個在CMAKE_PREFIX_PATH中的<prefix>/，路徑<prefix>/include
CMAKE_INCLUDE_PATH
CMAKE_FRAMEWORK_PATH
 

　　三、搜索由HINTS選項指定的路徑。這些路徑應該是由系統內省時計算得出的路徑，好比由其它已經發現的項目提供的線索。硬編碼的參考路徑應該在PATHS選項中指定。
 

　　四、搜索標準的系統環境變量。經過指定選項NO_SYSTEM_ENVIRONMENT_PATH能夠跳過搜索環境變量。搜索的路徑還包括：
 

PATH
INCLUDE
 

　　五、查找在爲當前系統的平臺文件中定義的cmake變量。若是指定了NO_CMAKE_SYSTEM_PATH選項，該路徑會被跳過。搜索的路徑還包括：
 

對於每一個在CMAKE_SYSTEM_PREFIX_PATH中的<prefix>，路徑<prefix>/include 
CMAKE_SYSTEM_LIBRARY_PATH
CMAKE_SYSTEM_FRAMEWORK_PATH
 

　　六、搜索PATHS選項或者精簡版命令指定的路徑。這些一般是硬編碼的推薦搜索路徑。
 

　　在Darwin或者支持OS X 框架的系統上，cmake變量CMAKE_FIND_FRAMEWORK能夠用來設置爲空，或者下述值之一：
 

"FIRST"  - 在標準庫或頭文件以前查找框架。在Darwin系統上這是默認選項。
"LAST"   - 在標準庫或頭文件以後查找框架。
"ONLY"   - 僅僅查找框架。
"NEVER" - 從不查找框架。
 

　　在Darwin或者支持OS X Application Bundles的系統，cmake變量CMAKE_FIND_APPBUNDLE能夠被設置爲空或者下面這些值中的一個：
 

"FIRST"  - 在標準庫或頭文件以前查找application bundles。在Darwin系統上這是默認選項。
"LAST"   - 在標準庫或頭文件以後查找application bundles。
"ONLY"   - 僅僅查找application bundles。
"NEVER" - 從不查找application bundles。
 

　　CMake變量CMAKE_FIND_ROOT_PATH指定了一個或者多個優先於其餘搜索路徑的搜索路徑。該變量可以有效地從新定位在給定位置下進行搜索的根路徑。該變量默認爲空。當使用交叉編譯時，該變量十分有用：用該變量指向目標環境的根目錄，而後CMake將會在那裏查找。默認狀況下，在CMAKE_FIND_ROOT_PATH中列出的路徑會首先被搜索，而後是「非根」路徑。該默認規則能夠經過設置CMAKE_FIND_ROOT_PATH_MODE_LIBRARY作出調整。在每次調用該命令以前，均可以經過設置這個變量來手動覆蓋默認行爲。若是使用了NO_CMAKE_FIND_ROOT_PATH變量，那麼只有重定位的路徑會被搜索。
 

　　默認的搜索順序的設計邏輯是按照使用時從最具體到最不具體的路徑。經過屢次調用find_path命令以及NO_*選項，能夠覆蓋工程的這個默認順序：
 

 

 

     
 
  1.  find_path(<VAR> NAMES name PATHS paths... NO_DEFAULT_PATH)
    2.  
 
  2.  find_path(<VAR> NAMES name)
    3.  

 

　　只要這些調用中的一個成功返回，結果變量就會被設置而且被存儲到cache中；這樣隨後的調用都不會再行搜索。在搜索框架時，若是以A/b.h的格式指定文件，那麼該框架搜索過程會搜索A.framework/Headers/b.h。若是找到了該路徑，它將會被設置爲框架的路徑。CMake將把它轉換爲正確的-F選項來包含該文件。
 

 

CMD#33 find_program
 

查找可執行程序
 

 

 

     
 
  1.  find_program(<VAR> name1 [path1 path2 ...])
    2.  

 

　　這是該命令的精簡格式，它在大多數場合下都夠用了。命令find_program(<VAR> name1 [PATHS path1 path2 ...])是它的等價形式。
 

 

 

     
 
  1.  find_program(
    2.  
 
  2.  <VAR>
    3.  
 
  3.  name | NAMES name1 [name2 ...]
    4.  
 
  4.  [HINTS path1 [path2 ... ENV var]]
    5.  
 
  5.  [PATHS path1 [path2 ... ENV var]]
    6.  
 
  6.  [PATH_SUFFIXES suffix1 [suffix2 ...]]
    7.  
 
  7.  [DOC "cache documentation string"]
    8.  
 
  8.  [NO_DEFAULT_PATH]
    9.  
 
  9.  [NO_CMAKE_ENVIRONMENT_PATH]
    10.  
 
  10.  [NO_CMAKE_PATH]
    11.  
 
  11.  [NO_SYSTEM_ENVIRONMENT_PATH]
    12.  
 
  12.  [NO_CMAKE_SYSTEM_PATH]
    13.  
 
  13.  [CMAKE_FIND_ROOT_PATH_BOTH |
    14.  
 
  14.  ONLY_CMAKE_FIND_ROOT_PATH |
    15.  
 
  15.  NO_CMAKE_FIND_ROOT_PATH]
    16.  
 
  16.  )
    17.  

 

　　該命令用於查找程序。一個名爲<VAR>的cache條目會被建立用來存儲該命令的結果。若是該程序被找到了，結果會存儲在該變量中，搜索過程將不會再重複，除非該變量被清除。若是沒有找到，結果將會是<VAR>-NOTFOUND，而且下次以相同的變量調用該命令時，還會作搜索的嘗試。被搜索的程序的名字由NAMES選項後列出的參數指定。附加的搜索位置能夠在PATHS參數後指定。若是在HINTS或者PATHS選項後有ENV var參數，環境變量var將會被讀取並從系統環境變量轉換爲cmake風格的路徑list。好比ENV PATH是一種列出全部系統path變量的方法。DOC後的參數將會被用做cache中的註釋字符串。PATH_SUFFIXES指定了在每一個搜索路徑下要檢查的附加子路徑。
 

　　若是指定了NO_DEFAULT_PATH選項，那麼搜索的過程當中不會有其餘的附加路徑。若是沒有指定該選項，搜索過程以下：
 

　　一、搜索cmake特有的cache變量指定的路徑。這些變量是在用cmake命令行時，經過-DVAR=value指定的變量。若是指定了NO_CMAKE_PATH選項，這些路徑會被跳過。搜索的路徑還包括：
 

對於每一個在CMAKE_PREFIX_PATH中的<prefix>，路徑<prefix>/[s]bin 
CMAKE_PROGRAM_PATH
CMAKE_APPBUNDLE_PATH
 

　　二、搜索cmake特有的環境變量指定的路徑。這些變量是用戶的shell配置中設置的變量。若是指定了NO_CMAKE_ENVIRONMENT_PATH選項，這些路徑會被跳過。搜索的路徑還包括：
 

對於每一個在CMAKE_PREFIX_PATH中的<prefix>，路徑<prefix>/[s]bin 
CMAKE_PROGRAM_PATH
CMAKE_APPBUNDLE_PATH
 

　　三、搜索由HINTS選項指定的路徑。這些路徑是系統內省(introspection)估算出的路徑，好比由另外一個已經發現的程序的地址提供的參考信息。硬編碼的推薦路徑應該經過PATHS選項指定。
 

　　四、查找標準的系統環境變量。若是指定了NO_SYSTEM_ENVIRONMENT_PATH選項，這些路徑會被跳過。搜索的路徑還包括：
 

PATH
 

　　五、查找在爲當前系統的平臺文件中定義的cmake變量。若是指定了NO_CMAKE_SYSTEM_PATH選項，該路徑會被跳過。搜索的路徑還包括：
 

對於每一個在CMAKE_SYSTEM_PREFIX_PATH中的<prefix>，路徑<prefix>/[s]bin 
CMAKE_SYSTEM_PROGRAM_PATH
CMAKE_SYSTEM_APPBUNDLE_PATH
 

　　六、搜索PATHS選項或者精簡版命令指定的路徑。這些一般是硬編碼的推薦搜索路徑。
 

　　在Darwin或者支持OS X 框架的系統上，cmake變量CMAKE_FIND_FRAMEWORK能夠設置爲空，或者下述值之一：
 

"FIRST"  - 在標準庫或頭文件以前查找框架。在Darwin系統上這是默認選項。
"LAST"   - 在標準庫或頭文件以後查找框架。
"ONLY"   - 僅僅查找框架。
"NEVER" - 從不查找框架。
 

　　在Darwin或者支持OS X Application Bundles的系統，cmake變量CMAKE_FIND_APPBUNDLE能夠被設置爲空或者下面這些值中的一個：
 

"FIRST"  - 在標準程序以前查找application bundles。在Darwin系統上這是默認選項。
"LAST"   - 在標準程序以後查找application bundles。
"ONLY"   - 僅僅查找application bundles。
"NEVER" - 從不查找application bundles。
 

　　CMake變量CMAKE_FIND_ROOT_PATH指定了一個或者多個優先於其餘搜索路徑的搜索路徑。該變量可以有效地從新定位在給定位置下進行搜索的根路徑。該變量默認爲空。當使用交叉編譯時，該變量十分有用：用該變量指向目標環境的根目錄，而後CMake將會在那裏查找。默認狀況下，在CMAKE_FIND_ROOT_PATH中列出的路徑會首先被搜索，而後是「非根」路徑。該默認規則能夠經過設置CMAKE_FIND_ROOT_PATH_MODE_LIBRARY作出調整。在每次調用該命令以前，均可以經過設置這個變量來手動覆蓋默認行爲。若是使用了NO_CMAKE_FIND_ROOT_PATH變量，那麼只有重定位的路徑會被搜索。
 

　　默認的搜索順序的設計邏輯是按照使用時從最具體到最不具體。經過屢次以NO_*選項調用find_program命令，能夠覆蓋工程的這個默認順序：
 

 

 

     
 
  1.  find_library(<VAR> NAMES name PATHS paths... NO_DEFAULT_PATH)
    2.  
 
  2.  find_library(<VAR> NAMES name)
    3.  

 

　　只要這些調用中的一個成功返回，結果變量就會被設置而且被存儲到cache中；這樣隨後的調用都不會再行搜索。
 

 

CMD#34 fltk_wrap_ui
 

建立FLTK用戶界面包裝器。
 

 

 

     
 
  1.  fltk_wrap_ui(resultingLibraryName source1
    2.  
 
  2.  source2 ... sourceN )
    3.  

 

　　爲全部列出的.fl和.fld文件生成.h和.cxx文件。這些生成的.h和.cxx文件將會加到變量resultingLibraryName_FLTK_UI_SRCS中，它也會加到你的庫中。 
　　 
　　
 

 

CMD#35 foreach
 

對一個list中的每個變量執行一組命令。
 

 

 

     
 
  1.  foreach(loop_var arg1 arg2 ...)
    2.  
 
  2.  COMMAND1(ARGS ...)
    3.  
 
  3.  COMMAND2(ARGS ...)
    4.  
 
  4.  ...
    5.  
 
  5.  endforeach(loop_var)
    6.  

 

　　全部的foreach和與之匹配的endforeach命令之間的命令會被記錄下來而不會被調用。等到遇到endforeach命令時，先前被記錄下來的命令列表中的每條命令都會爲list中的每一個變量調用一遍。在每次迭代中，循環變量${loop_var}將會被設置爲list中的當前變量值。
 

 

 

     
 
  1.  foreach(loop_var RANGE total)
    2.  
 
  2.  foreach(loop_var RANGE start stop [step])
    3.  

 

foreach命令也能夠遍歷一我的爲生成的數據區間。遍歷的方式有三種：
 

*若是指定了一個數字，區間是[0, total]。
*若是指定了兩個數字，區間將會是第一個數字到第二個數字。
*第三個數字是從第一個數字遍歷到第二個數字時的步長。
 

 

 

     
 
  1.  foreach(loop_var IN [LISTS [list1 [...]]]
    2.  
 
  2.  [ITEMS [item1 [...]]])
    3.  

 

　　該命令的含義是：精確遍歷一個項組成的list。LISTS選項後面是須要被遍歷的list變量的名字，包括空元素（一個空字符串是一個零長度list）。ITEMS選項結束了list參數的解析，而後在迭代中引入全部在其後出現的項。（猜想是用list1中的項item1，依次類推，爲循環變量賦值。——譯註） 
　　 
　　
 

 

CMD#36 : function
 

開始記錄一個函數，爲之後以命令的方式調用它作準備。
 

 

 

     
 
  1.  function(<name> [arg1 [arg2 [arg3 ...]]])
    2.  
 
  2.  COMMAND1(ARGS ...)
    3.  
 
  3.  COMMAND2(ARGS ...)
    4.  
 
  4.  ...
    5.  
 
  5.  endfunction(<name>)
    6.  

 

　　定義一個名爲<name>的函數，它以arg1 arg2 arg3 (...)爲參數。在function和endfunction以前列出的命令，在函數被調用以前是不會被調用的。當函數被調用時，在函數中記錄的那些命令首先會用傳進去的參數替換掉形參（${arg1}）；而後跟正常命令同樣去調用這些命令。除了形參，你還能夠引用這些變量：ARGC爲傳遞給函數的變量個數，ARGV0 ARGV1 ARGV2 ...表示傳到函數中的實參值。這些變量爲編寫可選參數函數提供了便利。此外，ARGV保留了一個該函數全部實參的list，ARGN保留了函數形參列表之後的全部參數列表。
 

　　參見cmake_policy()命令文檔中function內部策略行爲的相關行爲。
 

 

CMD#37 get_cmake_property
 

獲取一個CMake實例的屬性。
 

 

 

     
 
  1.  get_cmake_property(VAR property)
    2.  

 

　　從指定的CMake實例中獲取屬性。屬性的值存儲在變量VAR中。若是屬性不存在，CMake會報錯。一些會被支持的屬性包括：VATIABLES，COMMANDS，MACROS以及COMPONENTS。
 

 

CMD#38 get_directory_property
 

獲取DIRECTORY域中的某種屬性。
 

 

 

     
 
  1.  get_directory_property(<variable> [DIRECTORY <dir>] <prop-name>)
    2.  

 

　　在指定的變量中存儲路徑（directory）域中的某種屬性。若是該屬性沒有被定義，將會返回空字符串。DIRECTORY參數指定了要取出的屬性值的另外一個路徑。指定的路徑必須已經被CMake遍歷過了。
 

 

 

     
 
  1.  get_directory_property(<variable> [DIRECTORY <dir>]
    2.  
 
  2.  DEFINITION <var-name>)
    3.  

 

　　該命令從一個路徑中獲取一個變量的定義。這種格式在從另外一個路徑中獲取變量的定義時比較有用。
 

 

CMD#39 get_filename_component
 

獲得一個完整文件名中的特定部分。
 

 

 

     
 
  1.  get_filename_component(<VAR> FileName
    2.  
 
  2.  PATH|ABSOLUTE|NAME|EXT|NAME_WE|REALPATH
    3.  
 
  3.  [CACHE])
    4.  

 

　　將變量<VAR>設置爲路徑(PATH)，文件名(NAME)，文件擴展名(EXT)，去掉擴展名的文件名(NAME_WE)，完整路徑(ABSOLUTE)，或者全部符號連接被解析出的完整路徑(REALPATH)。注意，路徑會被轉換爲Unix的反斜槓(/)，而且沒有結尾的反斜槓。該命令已經考慮了最長的文件擴展名。若是指定了CACHE選項，獲得的變量會被加到cache中。
 

 

 

     
 
  1.  get_filename_component(<VAR> FileName
    2.  
 
  2.  PROGRAM [PROGRAM_ARGS <ARG_VAR>]
    3.  
 
  3.  [CACHE])
    4.  

 

　　在FileName中的程序將會在系統搜索路徑中被查找，或者是一個完整路徑。若是與PRPGRAM一塊兒給定了PROGRAM_ARGS選項，那麼任何在Filename字符串中出現的命令行中選項將會從程序名中分割出來並存儲在變量<ARG_VAR>中。這能夠用來從一個命令行字符串中分離程序名及其選項。 
　　 
　　 
　　
 

 

CMD#40 get_property
 

獲取一個屬性值
 

 

 

     
 
  1.  get_property(<variable>
    2.  
 
  2.  <GLOBAL |
    3.  
 
  3.  DIRECTORY [dir] |
    4.  
 
  4.  TARGET <target> |
    5.  
 
  5.  SOURCE <source> |
    6.  
 
  6.  TEST <test> |
    7.  
 
  7.  CACHE <entry> |
    8.  
 
  8.  VARIABLE>
    9.  
 
  9.  PROPERTY <name>
    10.  
 
  10.  [SET | DEFINED | BRIEF_DOCS | FULL_DOCS])
    11.  

 

　　獲取在某個域中一個對象的某種屬性值。第一個參數指定了存儲屬性值的變量。第二個參數肯定了獲取該屬性的域。域的選項僅限於：
 

GLOBAL 域是惟一的，它不接受域名字。
DIRECTORY域默認爲當前目錄，可是其餘的路徑（已經被CMake處理過）能夠以相對路徑或完整路徑的方式跟在該域後面。
TARGET域後面必須跟有一個已有的目標名。
SOURCE域後面必須跟有一個源文件名。
TEST域後面必須跟有一個已有的測試。
CACHE域後面必須跟有一個cache條目。
VARIABLE域是惟一的，它不接受域名字。
PROPERTY選項是必須的，它後面緊跟要獲取的屬性名。若是該屬性沒有被設置，該命令將返回空值。若是給定了SET選項，那麼返回值會被設置爲一個布爾值，用來指示該屬性是否被設置過。若是給定了DEFINED選項，那麼返回值會被設置爲一個布爾值，用來指示該屬性是否被相似於define_property的命令定義過。若是指定了BRIEF_DOCS或者FULL_DOCS選項，那麼該變量將會被設置爲被查詢屬性的文檔的字符串。若是被請求的屬性的文檔沒有被定義，將返回NOTFOUND。
 

 

CMD#41 get_source_file_property
 

爲一個源文件獲取一種屬性值。
 

 

 

     
 
  1.  get_source_file_property(VAR file property)
    2.  

 

　　從一個源文件中獲取某種屬性值。這個屬性值存儲在變量VAR中。若是該屬性沒有被找到，VAR會被設置爲NOTFOUND。使用set_source_files_proterties命令來設置屬性值。源文件屬性一般用來控制文件如何被構建。一個一定存在的屬性是LOCATION。
 

 

CMD#42 get_target_property
 

從一個目標中獲取一個屬性值。
 

 

 

     
 
  1.  get_target_property(VAR target property)
    2.  

 

　　從一個目標中獲取屬性值。屬性的值會被存儲在變量VAR中。若是該屬性沒有被發現，VAR會被設置爲NOTFOUND。使用set_target_properties命令來設置屬性值。屬性值通常用於控制如何去構建一個目標，可是有些屬性用來查詢目標的信息。該命令能夠獲取當前已經被構建好的任意目標的屬性。該目標不必定存在於當前的CMakeLists.txt文件中。
 

 

CMD#43 get_test_property
 

獲取一個測試的屬性。
 

 

 

     
 
  1.  get_test_property(test VAR property)
    2.  

 

　　從指定的測試中獲取某種屬性。屬性值會被存儲到變量VAR中。若是沒有找到該屬性，CMake將會報錯。你可使用命令cmake --help-property-list來獲取標準屬性的清單。
 

 

CMD#44 if
 

條件執行一組命令。
 

 

 

     
 
  1.  if(expression)
    2.  
 
  2.  # then section.
    3.  
 
  3.  COMMAND1(ARGS ...)
    4.  
 
  4.  COMMAND2(ARGS ...)
    5.  
 
  5.  ...
    6.  
 
  6.  elseif(expression2)
    7.  
 
  7.  # elseif section.
    8.  
 
  8.  COMMAND1(ARGS ...)
    9.  
 
  9.  COMMAND2(ARGS ...)
    10.  
 
  10.  ...
    11.  
 
  11.  else(expression)
    12.  
 
  12.  # else section.
    13.  
 
  13.  COMMAND1(ARGS ...)
    14.  
 
  14.  COMMAND2(ARGS ...)
    15.  
 
  15.  ...
    16.  
 
  16.  endif(expression)
    17.  

 

　　評估給定的表達式。若是結果是true，在THEN段的命令就會被調用。不然，在ELSE區段的命令會被調用。ELSEIF和ELSE區段是可選的 。能夠有多個ELSEIF子句。注意，在else和elseif子句中的表達式也是可選的。判斷條件能夠用長表達式，而且表達式有約定的優先級順序。括號中的表達式會首先被調用；而後是一元運算符，好比EXISTS，COMMAND以及DEFINED；而後是EQUAL，LESS，GREATER，STRLESS，STRGREATER，STREQUAL，MATCHES；而後是NOT運算符，最後是AND，OR運算符。幾種可能的表達式是： 
　　
 

 

 

     
 
  1.  if(<常量>)
    2.  
 
  2.  #若是<常量>是1，ON，YES，TRUE，Y或者非0數值，那麼表達式爲真；若是<常量>是0，OFF，NO，FALSE，N，IGNORE，""，或者以'-NOTFOUND'爲後綴，那麼表達式爲假。這些布爾常量值是大小寫無關的。
    3.  
 
    4.  
 
  4.  if(<變量>)
    5.  
 
  5.  #若是<變量>的值不是一個false常量，表達式爲真。
    6.  
 
    7.  
 
  7.  if(NOT <表達式>)
    8.  
 
  8.  #若是<表達式>的值是false的話，真個表達式爲真。
    9.  
 
    10.  
 
  10.  if(<表達式1> AND <表達式2>)
    11.  
 
  11.  #若是兩個表達式都爲真，整個表達式爲真。
    12.  
 
    13.  
 
  13.  if(<表達式1> OR <表達式2>)
    14.  
 
  14.  #只要有一個表達式爲真，整個表達式爲真。
    15.  
 
    16.  
 
  16.  if(COMMAND command-name)
    17.  
 
  17.  #若是給出的名字是一個能夠被調用的命令，宏，或者函數的話，整個表達式的值爲真。
    18.  
 
    19.  
 
  19.  if(POLICY policy-id)
    20.  
 
  20.  #若是給出的名字是一個已有的策略（格式是CMP<NNNN>），表達式爲真。
    21.  
 
    22.  
 
  22.  if(TARGET 目標名)
    23.  
 
  23.  #若是給出的名字是一個已有的構建目標或導入目標的話，表達式爲真。
    24.  
 
    25.  
 
  25.  if(EXISTS 文件名)
    26.  
 
  26.  if(EXISTS 路徑名)
    27.  
 
  27.  #若是給出的文件名或路徑名存在，表達式爲真。該命令只對完整路徑有效。
    28.  
 
    29.  
 
  29.  if(file1 IS_NEWER_THAN file2)
    30.  
 
  30.  #若是file1比file2更新或者其中的一個文件不存在，那麼表達式爲真。該命令只對完整路徑有效。
    31.  
 
    32.  
 
  32.  if(IS_DIRECTORY directory-name)
    33.  
 
  33.  #若是給定的名字是一個路徑，表達式返回真。該命令只對完整路徑有效。
    34.  
 
    35.  
 
  35.  if(IS_SYMLINK file-name)
    36.  
 
  36.  #若是給定的名字十一個符號連接的話，表達式返回真。該命令只對完整路徑有效。
    37.  
 
    38.  
 
  38.  if(IS_ABSOLUTE path)
    39.  
 
  39.  #若是給定的路徑是一個絕對路徑的話，表達式返回真。
    40.  
 
    41.  
 
  41.  if(variable MATCHES regex)
    42.  
 
  42.  if(string MATCHES regex)
    43.  
 
  43.  #若是給定的字串或變量值域給定的正則表達式匹配的話，表達式返回真。
    44.  
 
    45.  
 
  45.  if(variable LESS number)
    46.  
 
  46.  if(string LESS number)
    47.  
 
  47.  if(variable GREATER number)
    48.  
 
  48.  if(string GREATER number)
    49.  
 
  49.  if(variable EQUAL number)
    50.  
 
  50.  if(string EQUAL number)
    51.  
 
  51.  #若是給定的字串或變量值是一個有效的數字而且不等號或等號知足的話，表達式返回真。
    52.  
 
    53.  
 
  53.  if(variable STRLESS string)
    54.  
 
  54.  if(string STRLESS string)
    55.  
 
  55.  if(variable STRGREATER string)
    56.  
 
  56.  if(string STRGREATER string)
    57.  
 
  57.  if(variable STREQUAL string)
    58.  
 
  58.  if(string STREQUAL string)
    59.  
 
  59.  #若是給定的字串或變量值依字典序小於（或者大於，或者等於）右邊給出的字串或變量值的話，表達式返回真。
    60.  
 
    61.  
 
  61.  if(version1 VERSION_LESS version2)
    62.  
 
  62.  if(version1 VERSION_EQUAL version2)
    63.  
 
  63.  if(version1 VERSION_GREATER version2)
    64.  
 
  64.  #對版本號的各部分依次比較（版本號格式是major[.minor[.patch[.tweak]]]）version1和version2的大小。
    65.  
 
    66.  
 
  66.  if(DEFINED variable)
    67.  
 
  67.  #若是給定的變量被定義了的話，該表達式爲真。若是變量被設置了，它的值是真是假都無所謂。
    68.  
 
    69.  
 
  69.  if((expression) AND (expression OR (expression)))
    70.  
 
  70.  #在小括號內的表達式會首先被計算，而後才按照先前介紹的運算來計算。有內嵌的括號時，最裏的括號會做爲包含它們的表達式的計算過程的一部分。IF語句在CMake的歷史上出現的至關早，它擁有一些須要特殊介紹的便捷特性。IF表達式只有在其中有一個單一的保留值的時候，纔會精簡操做（即不作變量展開——譯註）；這些保留值包括：若是是大小寫無關的 ON，1， YES，TRUE，Y，它返回真；若是是OFF，0，NO，FALSE，N，NOTFOUND，*-NOTFOUND，IGNORE，它返回假。這種特性很是合理，它爲新做者提供了一種不須要精確匹配true或者false的便利性。這些值會被當作變量處理，即便它們沒有使用${}語法的時候，也會被解引用。
    71.  
 
    72.  
 
  72.  #這意味着，若是你寫下了這樣的語句： 
    73.  
 
  73.  if (boobah) 
    74.  
 
    75.  
 
  75.  #CMake將會把它當作你寫了 
    76.  
 
  76.  if (${boobah})
    77.  
 
    78.  
 
  78.  #來處理。相似地，若是你寫了
    79.  
 
  79.  if (fubar AND sol) 
    80.  
 
    81.  
 
  81.  #CMake將會便捷地把它解釋爲 
    82.  
 
  82.  if ("${fubar}" AND "${sol}")
    83.  
 
    84.  
 
  84.  #上述兩例的後者確實是正確的書寫方式，可是前者也是可行的。if語句中只有某些操做有這種特殊的變量處理方式。這些特殊的語句包括：
    85.  
 
  85.  # 對於MATCHES運算符，待匹配的左邊的參數首先被檢查，用來確認它是不是一個已經定義的變量；若是是，該變量的值會被使用，不然就會用它的原始值。
    86.  
 
  86.  # 若是MATCHES運算符沒有左邊的參數，它返回false，但不產生錯誤。 
    87.  
 
  87.  # LESS，GREATER，EQUAL運算符的左邊的參數和右邊的參數會被獨立測試，用來確認它們是不是被定義的變量；若是是，使用它們被定義的值，不然使用它們的原始值。
    88.  
 
  88.  # STRLESS，STRGREATER，STREQUAL運算符的左邊的參數和右邊的參數會被獨立測試，用來確認它們是不是被定義的變量；若是是，使用它們被定義的值，不然使用它們的原始值。
    89.  
 
  89.  # VERSIONLESS，VERSIONGREATER，VERSIONEQUAL運算符的左邊的參數和右邊的參數會被獨立測試，用來確認它們是不是被定義的變量；若是是，使用它們被定義的值，不然使用它們的原始值。
    90.  
 
  90.  # NOT運算符右邊的參數會被測試用來肯定它是不是布爾常量，若是是，就用這個常量；不然它會被當作一個變量而後被解引用。
    91.  
 
  91.  # AND和OR運算符的左邊的參數和右邊的參數會被獨立測試，用來確認它們是不是布爾常量；若是是，就用這個常量，不然它們會被當作變量而後被解引用。
    92.  

 

 

CMD#45 include
 

從給定的文件中讀取CMake的列表文件。
 

 

 

     
 
  1.  include(<file|module> [OPTIONAL] [RESULT_VARIABLE <VAR>]
    2.  
 
  2.  [NO_POLICY_SCOPE])
    3.  

 

　　從給定的文件中讀取CMake的清單文件代碼。在清單文件中的命令會被當即處理，就像它們是寫在這條include命令展開的地方同樣。若是指定了OPTIONAL選項，那麼若是被包含文件不存在的話，不會報錯。若是指定了RESULT_VARIABLE選項，那麼var或者會被設置爲被包含文件的完整路徑，或者是NOTFOUND，表示沒有找到該文件。
 

　　若是指定的是一個模塊(module)而不是一個文件，查找的對象會變成路徑CMAKE_MODULE_PATH下的文件<modulename>.camke。
 

　　參考cmake_policy()命令文檔中關於NO_POLICY_SCOPE選項的討論。 
　　 
　　
 

 

CMD#46 include_directories
 

爲構建樹添加包含路徑。
 

 

 

     
 
  1.  include_directories([AFTER|BEFORE] [SYSTEM] dir1 dir2 ...)
    2.  

 

　　將給定的路徑添加到編譯器搜索包含文件（.h文件）的路徑列表中。缺省狀況下，該路徑會被附加在當前路徑列表的後面。這種缺省行爲能夠經過設置CMAKE_include_directories_BEFORE變量爲ON被改變。經過將該變量改變爲BEFORE或AFTER，你能夠在追加和附加在前端這兩種方式中選擇，而不用理會缺省設置。若是指定了SYSTEM選項，編譯器將會認爲該路徑是某種平臺上的系統包含路徑。 
　　 
　　
 

 

CMD#47 include_external_msproject
 

在一個workspace中包含一個外部的Microsoft工程。　　　　　　
 

 

 

     
 
  1. 　　include_external_msproject(projectname location dep1 dep2 ...)
    2.  

 

　　在生成的workspace文件中包含一個外部的Microsoft工程。它會建立一個名爲[projectname]的目標。這個目標能夠用在add_dependencies命令中讓其餘工程依賴於這個外部工程。當前版本下，該命令在UNIX平臺上不會作任何事情。
 

 

CMD#48 include_regular_expression
 

設置用於依賴性檢查的正則表達式。
 

 

 

     
 
  1.  include_regular_expression(regex_match [regex_complain])
    2.  

 

　　設置依賴性檢查的正則表達式。這有匹配正則表達式regex_match的文件會成爲依賴性跟蹤的對象。只有匹配regex_complain的文件，在找不到它們的時候纔會給出警告（標準頭文件不會被搜索）。正則表達式的默認值是：
 

 

 

     
 
  1.  　　regex_match = "^.*$" (匹配全部文件)
    2.  
 
  2. 　　　regex_complain = "^$" (僅匹配空字符串)
    3.  

 

 

CMD#49 install
 

指定在安裝時要運行的規則。 
　　該命令爲一個工程生成安裝規則。在某一源文件路徑中，調用這條命令所指定的規則會在安裝時按順序執行。在不一樣路徑之間的順序未定義。
 

　　該命令有諸多版本。其中的一些版本定義了文件以及目標的安裝屬性。這多個版本的公共屬性都有所涉及，可是隻有在指定它們的版本中，這些屬性纔是合法的（下面的DESTIONATION到OPTIONAL的選項列表是公共屬性。——譯註）。
 

　　DESTINATION選項指定了一個文件會安裝到磁盤的哪一個路徑下。若果給出的是全路徑（以反斜槓或者驅動器名開頭），它會被直接使用。若是給出的是相對路徑，它會被解釋爲相對於CMAKE_INSTALL_PREFIX的值的相對路徑。
 

　　PERMISSIONS選項制定了安裝文件須要的權限。合法的權限有：OWNER_READ，OWNER_WRITE，OWNER_EXECUTE，GROUP_READ，GROUP_WRITE，GROUP_EXECUTE，WORLD_READ，WORLD_WRITE，WORLD_EXECUTE，SETUID和SETGID。對於在某些特定的平臺上沒有意義的權限，在這些平臺上會忽略這些選項。
 

　　CONFIGURATIONS選項指定了該安裝規則將會加諸之上的一系列的構建配置（Debug，Release，等等）。
 

　　COMPONENT選項指定了該安裝規則相關的一個安裝部件的名字，好比runtime或development。對於那些指定安裝部件的安裝過程來講，在安裝時只有與給定的部件名相關的安裝規則會被執行。對於完整安裝，全部部件都會被安裝。
 

　　RENAME選項爲一個可能不一樣於原始文件的已經安裝的文件指定另外一個名字。重命名只有在該命令正在安裝一個單一文件時才被容許（猜想是爲了防止文件名衝突時覆蓋掉舊文件。——譯註）。
 

　　OPTIONAL選項表示要安裝的文件不存在不會致使錯誤。
 

　　TARGETS版本的install命令
 

 

 

     
 
  1.  install(TARGETS targets... [EXPORT <export-name>]
    2.  
 
  2.  [[ARCHIVE|LIBRARY|RUNTIME|FRAMEWORK|BUNDLE|
    3.  
 
  3.  PRIVATE_HEADER|PUBLIC_HEADER|RESOURCE]
    4.  
 
  4.  [DESTINATION <dir>]
    5.  
 
  5.  [PERMISSIONS permissions...]
    6.  
 
  6.  [CONFIGURATIONS [Debug|Release|...]]
    7.  
 
  7.  [COMPONENT <component>]
    8.  
 
  8.  [OPTIONAL] [NAMELINK_ONLY|NAMELINK_SKIP]
    9.  
 
  9.  ] [...])
    10.  

 

　　TARGETS格式的install命令規定了安裝工程中的目標（targets）的規則。有5中能夠被安裝的目標文件：ARCHIVE，LIBRARY，RUNTIME，FRAMEWORK，和BUNDLE。除了被標記爲MACOSX_BUNDLE屬性的可執行文件被當作OS X上的BUNDLE目標外，其餘的可執行文件都被當作RUNTIME目標。靜態連接的庫文件老是被當作ARCHIVE目標。模塊庫老是被當作LIBRARY目標。對於動態庫不是DLL格式的平臺來講，動態庫會被當作LIBRARY目標來對待，被標記爲FRAMEWORK的動態庫是例外，它們被當作OS X上的FRAMEWORK目標。對於DLL平臺而言，動態庫的DLL部分被當作一個RUNTIME目標而對應的導出庫被當作是一個ARCHIVE目標。全部基於Windows的系統，包括Cygwin，都是DLL平臺。ARCHIVE，LIBRARY，RUNTIME和FRAMEWORK參數改變了後續屬性會加諸之上的目標的類型。若是隻給出了一種類型，那麼只有那種類型的目標會被安裝（這樣一般只會安裝一個DLL或者一個導出庫。）
 

　　PRIVATE_HEADER，PUBLIC_HEADER，和RESOURCE選項的功能是，在非蘋果平臺上，將後續的屬性應用在待安裝的一個FRAMEWORK共享庫目標的相關文件上。這些選項定義的規則在蘋果系統上會被忽略掉，由於相關的文件將會被安裝到framework文件夾內的合適位置。參見PRIVATE_HEADER，PUBLIC_HEADER和RESOURCE目標屬性中更爲詳細的解釋。
 

　　能夠指定NAMELINK_ONLY或者NAMELINK_SKIP選項做爲LIBRARY選項。在一些平臺上，版本化的共享庫有一個符號連接，好比lib<name>.so -> lib<name>.so.1，其中「lib<name>.so.1」是so庫文件名（soname）而「lib<name>.so」是一個符號連接，當指定「-l<name>」選項時，連接器將會查找這個符號連接。若是一個庫目標已經被安裝，NAMELINK_ONLY選項表示僅僅安裝符號連接；而NAME_SKIP選項則表示僅僅安裝庫文件而不是符號連接。當兩種選項都沒有給出時，動態庫的兩個部分都會被安裝。在那些版本化的共享庫沒有符號連接或者庫沒有被版本化的平臺，選項NAMELINK_SKIP安裝這個庫，而NAMELINK_ONLY選項什麼都不會安裝。參見VERSION和SOVERSION目標屬性，獲取關於建立版本化共享庫的更多細節。
 

　　在該命令的TARGETS版本的一次調用中，能夠一次性指定一個或多個屬性組。一個目標也能夠被屢次安裝到不一樣的位置。假設有三個目標myExe，mySharedLib和myStaticLib，下面的代碼
 

 

 

     
 
  1.  install(TARGETS myExe mySharedLib myStaticLib
    2.  
 
  2.  RUNTIME DESTINATION bin
    3.  
 
  3.  LIBRARY DESTINATION lib
    4.  
 
  4.  ARCHIVE DESTINATION lib/static)
    5.  
 
  5.  install(TARGETS mySharedLib DESTINATION /some/full/path)
    6.  

 

將會把myExe安裝到<prefix>/bin目錄下，把myStaticLib安裝到<prefix>/lib/static目錄下。在非-DLL平臺上，mySharedLib將會被安裝到<prefix>/lib和/some/full/path下。在DLL平臺上，mySharedLib DLL將會被安裝到<prefix>/bin和/some/full/path路徑下，它的導出庫會被安裝到<prefix>/lib/static和/some/full/path路徑下。
 

　　EXPORT選項將已經安裝的目標文件和一個名爲<export-name>的導出文件關聯起來。它必須出如今全部RUNTIME，LIBRARY或者ARCHIVE選項以前。爲了實際安裝導出文件(export file)自己，調用install(EXPORT)。參見下述install命令EXPORT版本的文檔獲取更多的細節。
 

　　將EXCLUDE_FROM_ALL設置爲true時，安裝一個目標會形成未定義的行爲。
 

　　FILES版本的install命令
 

 

 

     
 
  1.  install(FILES files... DESTINATION <dir>
    2.  
 
  2.  [PERMISSIONS permissions...]
    3.  
 
  3.  [CONFIGURATIONS [Debug|Release|...]]
    4.  
 
  4.  [COMPONENT <component>]
    5.  
 
  5.  [RENAME <name>] [OPTIONAL])
    6.  

 

　　FILES版本的install命令指定了爲一個工程安裝文件的規則。在命令中，以相對路徑方式給出的文件名是相對於當前源代碼路徑而言的。以這個版本安裝的文件，若是沒有指定PERMISSIONS選項，默認會具備OWNER_WRITE，OWNER_READ，GROUP_READ，和WORLD_READ的權限。
 

　　PROGRAMS版本的install命令
 

 

 

     
 
  1.  install(PROGRAMS files... DESTINATION <dir>
    2.  
 
  2.  [PERMISSIONS permissions...]
    3.  
 
  3.  [CONFIGURATIONS [Debug|Release|...]]
    4.  
 
  4.  [COMPONENT <component>]
    5.  
 
  5.  [RENAME <name>] [OPTIONAL])
    6.  

 

　　PROGRAMS版本與FILES版本同樣，只在默認權限上有所不一樣：它還包括了OWNER_EXECUTE，GROUP_EXECUTE和`WORLD_EXECUTE選項。INSTALL的這個版本用來安裝不是目標的程序，好比shell腳本。使用TARGETS格式安裝該工程內部構建的目標。
 

　　DIRECTORY版本的install命令
 

 

 

     
 
  1.  install(DIRECTORY dirs... DESTINATION <dir>
    2.  
 
  2.  [FILE_PERMISSIONS permissions...]
    3.  
 
  3.  [DIRECTORY_PERMISSIONS permissions...]
    4.  
 
  4.  [USE_SOURCE_PERMISSIONS] [OPTIONAL]
    5.  
 
  5.  [CONFIGURATIONS [Debug|Release|...]]
    6.  
 
  6.  [COMPONENT <component>] [FILES_MATCHING]
    7.  
 
  7.  [[PATTERN <pattern> | REGEX <regex>]
    8.  
 
  8.  [EXCLUDE] [PERMISSIONS permissions...]] [...])
    9.  

 

　　INSTALL的DIRECTORY版本將一個或者多個路徑下的內容安裝到指定的目標地址下。目錄結構會原封不動地（verbatim）拷貝到目標地址。每一個路徑名的最後一部分會追加到目標路徑下，可是結尾反斜槓(trailing slash)能夠用來避免這一點，由於這樣最後一部分就是空的。給定的相對路徑名被解釋成相對於當前源路徑的路徑。若是沒有指定輸入目錄名字，目標目錄會被建立，可是不會安裝任何東西。FILE_PERMISSIONS和DIRECTORY_PERMISSIONS選項指定了賦予目標路徑和目標文件的權限。若是指定了USE_SOURCE_PERMISSIONS選項，但沒有指定FILE_PERMISSIONS選項，文件權限將沿襲源目錄結構的權限，並且這個路徑會被賦予PAROGRAMS版本中指定的默認權限。
 

　　經過使用PATTERN或REGEX選項能夠對路徑安裝作出細粒度的控制。這些用於匹配的選項指定了一個查詢模式或正則表達式來匹配輸入路徑內的路徑或文件。它們能夠用來將特定的選項（見下文）加諸於遇到的文件和路徑的一個子集上。每一個輸入文件或路徑的完整路徑（反斜槓/開頭的路徑）將用來匹配該表達式。PATTERN僅僅用來匹配徹底文件名：匹配該模式的全路徑的那部分必須出如今文件名的結尾，而且必須以一個反斜槓開始。
 

　　正則表達式會用來匹配一個徹底路徑的任何部分，可是它也可使用'/'和'$'模仿PATTERN的行爲。默認狀況下，全部文件和路徑無論是否匹配都會被安裝。能夠在第一個匹配選項以前指定FILE_MATCHING選項，這樣就能禁止安裝那些不與任何表達式匹配的文件。好比，代碼
 

 

 

     
 
  1.  install(DIRECTORY src/ DESTINATION include/myproj
    2.  
 
  2.  FILES_MATCHING PATTERN "*.h")
    3.  

 

將會精確匹配並安裝從源碼樹上獲得的頭文件。
 

　　有些選項後面能夠跟在PATTERN或者REGEX表達式的後面，這樣這些選項只能加諸於匹配PATTERN/REGEX的文件或路徑上。EXCLUDE選項將會指示安裝過程跳過那些匹配的文件或者路徑。PERMISSIONS選項能夠覆蓋那些匹配PATTERN/REGEX的文件的權限設定。例如，代碼
 

 

 

     
 
  1.  install(DIRECTORY icons scripts/ DESTINATION share/myproj
    2.  
 
  2.  PATTERN "CVS" EXCLUDE
    3.  
 
  3.  PATTERN "scripts/*"
    4.  
 
  4.  PERMISSIONS OWNER_EXECUTE OWNER_WRITE OWNER_READ
    5.  
 
  5.  GROUP_EXECUTE GROUP_READ)
    6.  

 

會將icons路徑安裝到share/myproject/icons下，同時把scripts目錄安裝到share/myproj路徑下。icons將具有默認的文件權限，scripts將會被給與指定的權限，可是全部CVS路徑排除在外。
 

　　SCRIPT和CODE版本的install命令
 

 

 

     
 
  1.  install([[SCRIPT <file>] [CODE <code>]] [...])
    2.  

 

　　SCRIPT格式將會在安裝期調用給定的腳本文件。若是腳本文件名是一個相對路徑，它會被解釋爲相對於當前的源路徑。CODE格式將會在安裝期調用給定的CMake代碼。code被指定爲一個雙引號括起來的單獨的參數。例如，代碼
 

 

 

     
 
  1.  install(CODE "MESSAGE(\"Sample install message.\")")
    2.  

 

會在安裝時打印一條消息。
 

　　EXPORT版本的install命令
 

 

 

     
 
  1.  install(EXPORT <export-name> DESTINATION <dir>
    2.  
 
  2.  [NAMESPACE <namespace>] [FILE <name>.cmake]
    3.  
 
  3.  [PERMISSIONS permissions...]
    4.  
 
  4.  [CONFIGURATIONS [Debug|Release|...]]
    5.  
 
  5.  [COMPONENT <component>])
    6.  

 

　　EXPORT格式的install命令生成並安裝一個包含將安裝過程的安裝樹導入到另外一個工程中的CMake文件。Target格式的安裝過程與上文說起的使用EXPORT選項的install(TARGET ...)格式的命令中的EXPORT <export-name>選項是相關的。NAMESPACE選項會在它們被寫入到導入文件時加到目標名字以前。缺省時，生成的文件就是<export-name>.cmake；可是FILE選項能夠用來指定不一樣於次的文件名。FILE選項後面的參數必須是以「.cmake」爲擴展名的文件。若是指定了CONFIGURATIONS選項，那麼只有那些具名的配置中的一個被安裝時，這個文件纔會被安裝。並且，生成的導入文件只能涉及到匹配的目標配置版本。若是指定了一個COMPONENT選項，而且<component>與那個<export-name>相關的目標指定的部件不匹配，那麼行爲是未定義的。若是一個庫目標被包含在export之中，可是與之關聯的庫卻沒有揹包含，那麼結果是未指定的。
 

　　EXPORT格式能夠協助外部工程使用當前工程構建出來並安裝的目標。例如，代碼
 

 

 

     
 
  1.  install(TARGETS myexe EXPORT myproj DESTINATION bin)
    2.  
 
  2.  install(EXPORT myproj NAMESPACE mp_ DESTINATION lib/myproj)
    3.  

 

將會把可執行文件myexe安裝到<prefix>/bin下，而且將導入它的代碼寫到文件"<prefix>/lib/myproj/myproj.cmake"中。一個外部工程能夠用include命令加載這個文件，而且能夠在安裝樹上使用導入的目標名mp_myexe（前綴_目標名——譯註）引用myexe可執行文件，如同這個目標是它自身的構建樹的內置目標同樣。
 

　　注意：這個命令會取代INSTALL_TARGETS命令以及PRE_INSTALL_SCRIPT和POST_INSTALL_SCRIPT兩個目標屬性。它也能夠取代FILES格式的INSTALL_FILES命令和INSTALL_PROGRAMS命令。由INSTALL命令生成的安裝規則相對於那些由INSTALL_TARGETS，INSTALL_FILES和INSTALL_PROGRAMS命令生成的安裝規則處理順序是未定義的。 
　　 
　　
 

 

CMD#50 link_directories
 

指定鏈接器查找庫的路徑。
 

 

 

     
 
  1.  link_directories(directory1 directory2 ...)
    2.  

 

　　指定鏈接器搜索庫文件時的路徑。該命令僅僅能用在那些在它被調用後才生成的目標上。因爲歷史上的緣由，爲該命令指定的相對路徑將會不加改變地傳遞給鏈接器（不像許多其餘CMake命令那樣解釋爲相對於當前源路徑的相對路徑。） 
　　 
　　
 

 

CMD#51 list
 

列表操做命令。
 

 

 

     
 
  1.  　　list(LENGTH <list> <output variable>)
    2.  
 
  2.  　　list(GET <list> <element index> [<element index> ...] <output variable>)
    3.  
 
  3.  　　list(APPEND <list> <element> [<element> ...])
    4.  
 
  4.  　　list(FIND <list> <value> <output variable>)
    5.  
 
  5.  　　list(INSERT <list> <element_index> <element> [<element> ...])
    6.  
 
  6.  　　list(REMOVE_ITEM <list> <value> [<value> ...])
    7.  
 
  7.  　　list(REMOVE_AT <list> <index> [<index> ...])
    8.  
 
  8.  　　list(REMOVE_DUPLICATES <list>)
    9.  
 
  9.  　　list(REVERSE <list>)
    10.  
 
  10.  　　list(SORT <list>)
    11.  

 

　　使用LENGTH選項時，該命令會返回給定list的長度。
 

　　使用GET選項時，該命令返回list中全部被index索引的元素構成的list。
 

　　使用APPEND選項時，該命令將會在該list以後追加若干元素。
 

　　使用FIND選項時，該命令將返回list中指定的元素的索引；若果未找到，返回-1。
 

　　使用INSERT選項時，該命令將在list中指定的位置插入若干元素。
 

　　使用REMOVE_AT和REMOVE_ITEM選項將會從list中刪除一些元素。它們之間的區別是：REMOVE_ITEM刪除的是指定的項，而REMOVE_AT刪除的是在指定索引處的項。
 

　　使用REMOVE_DUPLICATES選項時，該命令將刪除list中的重複項。
 

　　使用REVERSE選項時，該命令將把list的內容就地先後倒換。
 

　　使用SORT選項時，該命令將按字母序對list總的內容就地排序。
 

　　注意：在CMake中，一個list是一個由分號;分割的一組字符串。使用set命令能夠建立一個list。例如，set(var a b c d e)命令將會建立一個list:a;b;c;d;e, 而set(var "a b c d e")命令建立的只是一個字符串, 或者說是隻有一個項的list。
 

　　當使用指定索引的命令格式時，若是<element index>是大於等於0的數，<element index>是從list第一個項開始的序號，list的第一項的索引是0。若是<element index>小於等於-1，這個索引是從結尾開始的逆向索引，其中-1表示的是list的最後一項。當使用負數索引時，(注意它們不是從0開始!!!!), -0與0等價，它指向list的第一個成員。
 

 

CMD#52 load_cache
 

從另外一個工程的CMake cache中加載值。
 

 

 

     
 
  1.  　　load_cache(pathToCacheFile READ_WITH_PREFIX
    2.  
 
  2.  prefix entry1...)
    3.  

 

　　該命令讀取指定的cache文件，並將以請求的前綴爲其前綴的那些cache文件中的entry(ies)保存到變量中。這個格式僅僅讀取值，可是不在本地工程的cache中建立entry(ies)。
 

 

 

     
 
  1.  　　load_cache(pathToCacheFile [EXCLUDE entry1...]
    2.  
 
  2.  [INCLUDE_INTERNALS entry1...])
    3.  

 

　　從另外一個cache文件中加載值並像內部entry(ies)那樣，將它們存儲到本地工程的cache中。這條命令對於一個依賴於另外一個不一樣構建樹上的另外一個工程的工程比較有用。EXCLUDE選項給出了那些須要排除在外的entry(ies)的一個list。INCLUDE_INTERNALS選項給出了須要包含的entry(ies)的內部entry(ies)的一個list。一般狀況下，不須要引入內部entry(ies)。強烈不推薦使用該命令的這種格式，可是它能夠被用來維持向後兼容性。
 

 

CMD#53 load_command
 

將一條命令加載到一個運行中的CMake。
 

 

 

     
 
  1.  　　load_command(COMMAND_NAME <loc1> [loc2 ...])
    2.  

 

　　該命令將在給定的路徑下查找名字爲COMMAND_NAME的一個庫。若是找到了，它將會以模塊的方式被加載，而後該命令將會被添加到可用的CMake命令集中。一般，TRY_COMPILE選項被用在這個命令以前來編譯這個模塊。若是該命令被成功加載，一個名爲CMAKE_LOADED_COMMAND_<COMMAND_NAME>的變量將會被設置爲這個加載模塊的完整路徑。不然，這個變量就不會被設置。
 

 

CMD#54 macro
 

爲後續以命令方式調用而開始記錄一組宏。
 

 

 

     
 
  1.  　　macro(<name> [arg1 [arg2 [arg3 ...]]])
    2.  
 
  2.  　　COMMAND1(ARGS ...)
    3.  
 
  3.  　　COMMAND2(ARGS ...)
    4.  
 
  4.  　　...
    5.  
 
  5.  　　endmacro(<name>)
    6.  

 

　　定義一個名爲<name>的宏，它以arg1 arg2 arg3 (...)爲參數。在macro命令以後，在與之配對的endmacro命令以前出現的命令，只有在宏被調用的時候纔會被調用。當被調用的時候，這些被記錄的命令首先以傳進來的實參替換掉形參(如${arg1})，而後像正常的命令那樣執行。除了形參以外，你還能夠引用變量${ARGC}}，它表示傳遞到宏裏的參數的數量；${ARG0}, ${ARG1}, ${ARG2} ...等等則是傳進來的實參值。這些變量使得建立帶可選參數的宏變得很便捷。此外，變量${ARGV}保留了全部傳遞到宏裏的全部參數組成的一個list，變量${ARGN}保留了在最後一個形參以後的參數組成的一個list。注意：傳遞到宏內部的參數和值，好比ARGN不是CMake一般意義下的變量；它們只是字符串替換，這一點很是像C預處理器對C語言宏的處理過程。若是你想要用真正的CMake變量，你應該查看一下function命令的說明。
 

　　關於在macro內部的策略的行爲，參見cmake_policy()命令的相關文檔。
 

 

CMD#55 mark_as_advanced
 

將CMake 的緩存變量標記爲高級。
 

 

 

     
 
  1.  　　mark_as_advanced([CLEAR|FORCE] VAR VAR2 VAR...)
    2.  

 

　　將緩存的變量標記爲高級變量。其中，高級變量指的是那些在cmake GUI中，只有當「顯示高級選項」被打開時纔會被顯示的變量。若是CLEAR是第一個選項，參數中的高級變量將變回非高級變量。若是FORCE是第一個選項，參數中的變量會被提高爲高級變量。若是二者都未出現，新的變量會被標記爲高級變量；若是這個變量已是高級/非高級狀態`的話，它將會維持原狀。
 

　　該命令在腳本中無效。
 

 

CMD#56 math
 

數學表達式。
 

 

 

     
 
  1.  　　math(EXPR <output variable> <math expression>)
    2.  

 

　　EXPR計算數學表達式而後經過output變量返回計算結果。數學表達式的一個例子是"5*(10+13)"。該命令支持的運算符包括：+ - * / % ^ ~ << >> ；它們的含義與C語言中的徹底一致。
 

 

CMD#57 message
 

爲用戶顯示一條消息。
 

 

 

     
 
  1.  　　message([STATUS|WARNING|AUTHOR_WARNING|FATAL_ERROR|SEND_ERROR]
    2.  
 
  2.  "message to display" ...)
    3.  

 

　　能夠用下述可選的關鍵字指定消息的類型：
 

(無)         　 = 重要消息；
 STATUS         = 非重要消息；
 WARNING        = CMake 警告, 會繼續執行；
 AUTHOR_WARNING = CMake 警告 (dev), 會繼續執行；
 SEND_ERROR     = CMake 錯誤, 繼續執行，可是會跳過生成的步驟；
 FATAL_ERROR    = CMake 錯誤, 終止全部處理過程；
 

　　CMake的命令行工具會在stdout上顯示STATUS消息，在stderr上顯示其餘全部消息。CMake的GUI會在它的log區域顯示全部消息。交互式的對話框（ccmake和CMakeSetup）將會在狀態行上一次顯示一條STATUS消息，而其餘格式的消息會出如今交互式的彈出式對話框中。
 

　　CMake警告和錯誤消息的文本顯示使用的是一種簡單的標記語言。文本沒有縮進，超過長度的行會回捲，段落之間以新行作爲分隔符。 
　　 
　　 
　　
 

 

CMD#58 option
 

爲用戶提供一個可選項。
 

 

 

     
 
  1.  option(<option_variable> "描述選項的幫助性文字" [initial value])
    2.  

 

　　該命令爲用戶提供了一個在ON和OFF中作出選擇的選項。若是沒有指定初始值，將會使用OFF做爲初值。若是有些選項依賴於其餘選項的值，參見CMakeDependentOption模塊的幫助文件。
 

 

CMD#59: output_required_files
 

輸出一個list，其中包含了一個給定源文件所須要的其餘源文件。
 

 

 

     
 
  1.  output_required_files(srcfile outputfile)
    2.  

 

　　輸出一個指定的源文件所須要的全部源文件的list。這個list會寫到outputfile變量中。該命令的功能是將srcfile的依賴性寫出到outputfile中，不過該命令將盡量地跳過.h文件，搜索依賴中的.cxx，.c和.cpp文件。
 

 

CMD#60 project
 

爲整個工程設置一個工程名。
 

 

 

     
 
  1.  project(<projectname> [languageName1 languageName2 ... ] )
    2.  

 

　　爲本工程設置一個工程名。並且，該命令還將變量<projectName>_BINARY_DIR和<projectName>_SOURCE_DIR設置爲對應值。後面的可選項還可讓你指定你的工程能夠支持的語言。好比CXX(即C++)，C，Fortran，等等。在默認條件下，支持C和CXX語言。例如，若是你沒有C++編譯器，你能夠經過列出你想要支持的語言，例如C，來明確地禁止對它的檢查。使用特殊語言"NONE"，針對任何語言的檢查都會被禁止。
 

 

CMD#61 qt_wrap_cpp
 

建立Qt包裹器。
 

 

 

     
 
  1.  qt_wrap_cpp(resultingLibraryName DestName SourceLists ...)
    2.  

 

　　爲全部在SourceLists中列出的.h文件生成moc文件。這些moc文件將會被添加到那些使用DestName源文件列表的庫文件中。
 

Produce moc files for all the .h files listed in the SourceLists. The moc files will be added to the library using the DestName source list.
 

 

CMD#62 qt_wrap_ui
 

建立Qt的UI包裹器。
 

 

 

     
 
  1.  qt_wrap_ui(resultingLibraryName HeadersDestName SourcesDestName SourceLists ...)
    2.  

 

　　爲全部在SourceLists中列出的.ui文件生成.h和.cxx文件。這些.h文件會被添加到使用HeadersDestNamesource列表的庫中。這些.cxx文件會被添加到使用SourcesDestNamesource列表的庫中。
 

 

CMD#63 remove_definitions
 

取消由add_definitions命令添加的-D定義標誌。
 

 

 

     
 
  1.  remove_definitions(-DFOO -DBAR ...)
    2.  

 

　　在當前及如下的路徑，從編譯命令行中取消（由add_definitions命令添加的）標誌。
 

 

CMD#64 return
 

從一個文件，路徑或函數內返回。
 

 

 

     
 
  1.  return()
    2.  

 

　　從一個文件，路徑或函數中返回。若出如今一個include文件裏（經由include()或find_package()命令），該命令會致使當前文件的處理過程中止，而且將控制權轉移到試圖包含它的文件中。若出如今一個不被任何文件包含的文件中，例如，一個CMakeLists.txt中，那麼該命令將控制權轉移到父目錄下，若是存在這樣的父目錄的話。若是在一個函數中調用return函數，控制權會返回到該函數的調用函數那裏。注意，宏不是函數，它不會像函數那樣去處理return命令。 
　　 
　　 
　　
 

 

CMD#65 separate_arguments
 

將空格分隔的參數解析爲一個分號分隔的list。
 

 

 

     
 
  1.  separate_arguments(<var> <UNIX|WINDOWS>_COMMAND "<args>")
    2.  

 

　　解析一個unix或者windows風格的命令行字符串"<args>"，並將結果以分號分隔的list的形式存儲到<var>中。整個命令行都必須從這個"<args>"參數中給出。
 

　　UNIX_COMMAND模式以沒有被括起來的白字符爲參數的分隔符。它能夠識別單引號和雙引號的引號對。反斜槓能夠對下一個字符的字面值轉義（\"，就是"）;沒有其餘特殊的轉義字符（例如\n就是n）。
 

　　WINDOWS_COMMAND模式按照與運行時庫相同的語法解析一個windows命令行，在啓動(starrtup)時構造argv。它使用沒有被雙引號括起來的白字符來分隔參數。反斜槓維持其字面含義，除非它們在雙引號以前。更多細節，參見MSDN的文章："Parsing C Command-Line Arguments"。
 

 

 

     
 
  1.  separate_arguments(VARIABLE)
    2.  

 

　　將VARIABLE的值轉換爲一個分號分隔的list。全部的空格會被替換爲';;'。該命令能夠用來輔助生成命令行。
 

 

CMD#66 set
 

將一個CMAKE變量設置爲給定值。
 

 

 

     
 
  1.  set(<variable> <value> [[CACHE <type> <docstring> [FORCE]] | PARENT_SCOPE])
    2.  

 

　　將變量<variable>的值設置爲<value>。在<variable>被設置以前，<value>會被展開。若是有CACHE選項，那麼<variable>就會添加到cache中；這時<type>和<docstring>是必需的。<type>被CMake GUI用來選擇一個窗口，讓用戶設置值。<type>能夠是下述值中的一個：
 

FILEPATH = 文件選擇對話框。
PATH     = 路徑選擇對話框。
STRING   = 任意的字符串。
BOOL     = 布爾值選擇複選框。
INTERNAL = 不須要GUI輸入端。(適用於永久保存的變量)。
 

　　若是<type>是內部(INTERNAL)的，那麼<value>老是會被寫入到cache中，並替換任何已經存在於cache中的值。若是它不是一個cache變量，那麼這個變量老是會寫入到當前的makefile中。FORCE選項將覆蓋cache值，從而去掉任何用戶帶來的改變。
 

　　若是指定了PARENT_SCOPE選項，變量<variable>將會被設置爲當前做用域之上的做用域中。每個新的路徑或者函數均可以建立一個新做用域。該命令將會把一個變量的值設置到父路徑或者調用函數中（或者任何相似的可用的情形中。）
 

　　若是沒有指定<value>，那麼這個變量就會被撤銷而不是被設置。另見：unset()命令。


        

            

        	





    

		

            
相關文章

            

                

                

                    

                

            


            
相關標籤/搜索

            
        


    

        

            

        

        

        
        

        

        

    




	

    





    

    	

    

        每日一句
    

    
    
    	每一个你不满意的现在，都有一个你没有努力的曾经。
    







    

    


    



    

        本站公眾號
    

    

           歡迎關注本站公眾號,獲取更多信息

        
    




    

    




	


	







    

        聯繫我們
        最近搜索
        最新文章
        
        沪ICP备13005482号-10

            MyBatis教程
            SQL 教程
            MySQL教程
            Java 教程
            Thymeleaf 教程
            Hibernate教程
            Spring教程 
            Redis教程