這不是最新的 CMake 版本。請參閱主要CMake 文件索引以取得更新的版本。
CMake 2.6 文件是使用 `cmake --help-html` 從 cmake 程式產生的。
cmake - cmake

主索引

名稱

  cmake - Cross-Platform Makefile Generator.

用法

  cmake [options] <path-to-source>
  cmake [options] <path-to-existing-build>

描述

「cmake」可執行檔是 CMake 的命令列介面。它可用於在腳本中配置專案。專案配置設定可以使用 `-D` 選項在命令列中指定。`-i` 選項會讓 cmake 以互動方式提示這些設定。

CMake 是一個跨平台的建構系統產生器。專案使用與平台無關的 CMake 列表檔案來指定其建構過程，該檔案包含在原始程式樹的每個目錄中，並命名為 CMakeLists.txt。使用者透過使用 CMake 為其平台上的原生工具產生建構系統來建構專案。

選項

  • -C <initial-cache>：預先載入腳本以填入快取。

    當 cmake 首次在空的建構樹中執行時，它會建立一個 CMakeCache.txt 檔案並使用專案的可自訂設定來填入它。此選項可用於指定在第一次掃描專案的 cmake 列表檔案之前，要從中載入快取項目的檔案。載入的項目優先於專案的預設值。給定的檔案應該是包含使用 CACHE 選項的 SET 命令的 CMake 腳本，而不是快取格式的檔案。

  • -D <var>:<type>=<value>：建立一個 cmake 快取項目。

    當 cmake 首次在空的建構樹中執行時，它會建立一個 CMakeCache.txt 檔案並使用專案的可自訂設定來填入它。此選項可用於指定優先於專案預設值的設定。可以重複使用此選項來指定所需數量的快取項目。

  • -U <globbing_expr>：從 CMake 快取中移除符合的項目。

    此選項可用於從 CMakeCache.txt 檔案中移除一個或多個變數，支援使用 * 和 ? 的萬用字元運算式。可以重複使用此選項來指定所需數量的快取項目。

    請謹慎使用，您可能會使您的 CMakeCache.txt 無法運作。

  • -G <generator-name>：指定 makefile 產生器。

    CMake 可能在某些平台上支援多個原生建構系統。makefile 產生器負責產生特定的建構系統。可能的產生器名稱在「產生器」區段中指定。

  • -Wno-dev：抑制開發人員警告。

    抑制用於 CMakeLists.txt 檔案作者的警告。

  • -Wdev：啟用開發人員警告。

    啟用用於 CMakeLists.txt 檔案作者的警告。

  • -E：CMake 命令模式。

    為了真正的平台獨立性，CMake 提供了一系列可在所有系統上使用的命令。使用 `-E help` 執行以取得使用資訊。可用的命令有：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。

  • -i：在精靈模式下執行。

    精靈模式在沒有 GUI 的情況下以互動方式執行 cmake。系統會提示使用者回答有關專案配置的問題。答案用於設定 cmake 快取值。

  • -L[A][H]：列出非進階快取變數。

    列出快取變數將會執行 CMake 並列出 CMake 快取中所有未標記為 INTERNAL 或 ADVANCED 的變數。這將有效地顯示目前的 CMake 設定，然後可以使用 `-D` 選項進行變更。變更某些變數可能會導致建立更多變數。如果指定 A，則也會顯示進階變數。如果指定 H，則也會顯示每個變數的說明。

  • -N：僅檢視模式。

    僅載入快取。實際上不執行配置和產生步驟。

  • -P <file>：處理腳本模式。

    將給定的 cmake 檔案作為以 CMake 語言編寫的腳本處理。不執行配置或產生步驟，也不修改快取。如果使用 `-D` 定義變數，則必須在 `-P` 參數之前完成。

  • --graphviz=[file]：產生相依性的 graphviz。

    產生一個 graphviz 輸入檔案，其中包含專案中所有程式庫和可執行檔的相依性。

  • --system-information [file]：傾印有關此系統的資訊。

    傾印有關目前系統的各種資訊。如果從 CMake 專案的二進位樹的頂部執行，它將會傾印額外的資訊，例如快取、記錄檔案等。

  • --debug-trycompile：不要刪除嘗試編譯的目錄。

    不要刪除為 try_compile 呼叫建立的檔案和目錄。這在偵錯失敗的嘗試編譯時很有用。但是，它可能會更改嘗試編譯的結果，因為先前嘗試編譯中的舊垃圾可能會導致不同的測試通過或失敗不正確。此選項最好一次用於一個嘗試編譯，並且僅在偵錯時使用。

  • --debug-output：將 cmake 置於偵錯模式。

    在 cmake 執行期間列印額外的內容，例如帶有 message(send_error) 呼叫的堆疊追蹤。

  • --trace：將 cmake 置於追蹤模式。

    使用 message(send_error) 呼叫列印所有呼叫的追蹤以及呼叫來源。

  • --help-command cmd [file]：列印單個命令的說明並結束。

    顯示給定命令的完整文件。如果指定了檔案，則會將文件寫入其中，並且輸出格式取決於檔案名稱的後綴。支援 man page、HTML、DocBook 和純文字。

  • --help-command-list [file]：列出可用的列表檔案命令並結束。

    此列表包含所有可以使用 `--help-command` 參數後接命令名稱來取得說明的命令。如果指定了檔案，則會將文件寫入其中，並且輸出格式取決於檔案名稱的後綴。支援 man page、HTML、DocBook 和純文字。

  • --help-commands [file]：列印所有命令的說明並結束。

    顯示所有目前命令的完整文件。如果指定了檔案，則會將文件寫入其中，並且輸出格式取決於檔案名稱的後綴。支援 man page、HTML、DocBook 和純文字。

  • --help-compatcommands [file]：列印相容性命令的說明。

    顯示所有相容性命令的完整文件。如果指定了檔案，則會將文件寫入其中，並且輸出格式取決於檔案名稱的後綴。支援 man page、HTML、DocBook 和純文字。

  • --help-module module [file]：列印單個模組的說明並結束。

    顯示給定模組的完整文件。如果指定了檔案，則會將文件寫入其中，並且輸出格式取決於檔案名稱的後綴。支援 man page、HTML、DocBook 和純文字。

  • --help-module-list [file]：列出可用的模組並結束。

    此列表包含所有可以使用 `--help-module` 參數後接模組名稱來取得說明的模組。如果指定了檔案，則會將文件寫入其中，並且輸出格式取決於檔案名稱的後綴。支援 man page、HTML、DocBook 和純文字。

  • --help-modules [file]：列印所有模組的說明並結束。

    顯示所有模組的完整文件。如果指定了檔案，則會將文件寫入其中，並且輸出格式取決於檔案名稱的後綴。支援 man page、HTML、DocBook 和純文字。

  • --help-custom-modules [file]：列印所有自訂模組的說明並結束。

    會顯示所有自訂模組的完整文件。 如果指定檔案，文件將會寫入該檔案，並且輸出格式會根據檔名後綴決定。 支援 man page、HTML、DocBook 和純文字。

  • --help-policy cmp [file]: 列印單一政策的說明並結束。

    會顯示指定政策的完整文件。如果指定檔案，文件將會寫入該檔案，並且輸出格式會根據檔名後綴決定。 支援 man page、HTML、DocBook 和純文字。

  • --help-policies [file]: 列印所有政策的說明並結束。

    會顯示所有政策的完整文件。如果指定檔案，文件將會寫入該檔案，並且輸出格式會根據檔名後綴決定。 支援 man page、HTML、DocBook 和純文字。

  • --help-property prop [file]: 列印單一屬性的說明並結束。

    會顯示指定屬性的完整文件。如果指定檔案，文件將會寫入該檔案，並且輸出格式會根據檔名後綴決定。 支援 man page、HTML、DocBook 和純文字。

  • --help-property-list [file]: 列出可用的屬性並結束。

    此清單包含所有可透過使用 --help-property 引數後接屬性名稱來取得說明的屬性。 如果指定檔案，說明將會寫入該檔案。如果指定檔案，文件將會寫入該檔案，並且輸出格式會根據檔名後綴決定。 支援 man page、HTML、DocBook 和純文字。

  • --help-properties [file]: 列印所有屬性的說明並結束。

    會顯示所有屬性的完整文件。如果指定檔案，文件將會寫入該檔案，並且輸出格式會根據檔名後綴決定。 支援 man page、HTML、DocBook 和純文字。

  • --help-variable var [file]: 列印單一變數的說明並結束。

    會顯示指定變數的完整文件。如果指定檔案，文件將會寫入該檔案，並且輸出格式會根據檔名後綴決定。 支援 man page、HTML、DocBook 和純文字。

  • --help-variable-list [file]: 列出有文件的變數並結束。

    此清單包含所有可透過使用 --help-variable 引數後接變數名稱來取得說明的變數。 如果指定檔案，說明將會寫入該檔案。如果指定檔案，文件將會寫入該檔案，並且輸出格式會根據檔名後綴決定。 支援 man page、HTML、DocBook 和純文字。

  • --help-variables [file]: 列印所有變數的說明並結束。

    會顯示所有變數的完整文件。如果指定檔案，文件將會寫入該檔案，並且輸出格式會根據檔名後綴決定。 支援 man page、HTML、DocBook 和純文字。

  • --copyright [file]: 列印 CMake 的版權聲明並結束。

    如果指定檔案，版權聲明將會寫入該檔案。

  • --help: 列印使用資訊並結束。

    使用說明描述基本命令列介面及其選項。

  • --help-full [file]: 列印完整說明並結束。

    完整說明會顯示 UNIX man page 提供的大部分文件。 它是為在非 UNIX 平台上使用而提供，但如果沒有安裝 man page，它也很方便。 如果指定檔案，說明將會寫入該檔案。

  • --help-html [file]: 列印 HTML 格式的完整說明。

    此選項供 CMake 作者用來協助產生網頁。 如果指定檔案，說明將會寫入該檔案。

  • --help-man [file]: 列印 UNIX man page 格式的完整說明並結束。

    此選項供 cmake 建置用來產生 UNIX man page。 如果指定檔案，說明將會寫入該檔案。

  • --version [file]: 顯示程式名稱/版本標題並結束。

    如果指定檔案，版本資訊將會寫入該檔案。

產生器

以下產生器在此平台上可用

  • Borland Makefiles: 產生 Borland makefiles。
  • MSYS Makefiles: 產生 MSYS makefiles。

    這些 makefiles 使用 /bin/sh 作為 shell。 它們需要在機器上安裝 msys。

  • MinGW Makefiles: 產生用於 mingw32-make 的 make 檔。

    產生的 makefiles 使用 cmd.exe 作為 shell。 它們不需要 msys 或 unix shell。

  • NMake Makefiles: 產生 NMake makefiles。
  • Unix Makefiles: 產生標準 UNIX makefiles。

    UNIX makefiles 的階層會產生到建置樹狀結構中。 任何標準 UNIX 樣式的 make 程式都可以透過預設 make 目標來建置專案。 也提供了「make install」目標。

  • 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: 產生 CodeBlocks 專案檔。

    CodeBlocks 的專案檔將會在頂層目錄和每個具有包含 PROJECT() 呼叫的 CMakeLists.txt 檔案的子目錄中建立。 此外，makefiles 的階層會產生到建置樹狀結構中。 適當的 make 程式可以透過預設的 make 目標來建置專案。 也提供了「make install」目標。

  • CodeBlocks - Unix Makefiles: 產生 CodeBlocks 專案檔。

    CodeBlocks 的專案檔將會在頂層目錄和每個具有包含 PROJECT() 呼叫的 CMakeLists.txt 檔案的子目錄中建立。 此外，makefiles 的階層會產生到建置樹狀結構中。 適當的 make 程式可以透過預設的 make 目標來建置專案。 也提供了「make install」目標。

  • Eclipse CDT4 - MinGW Makefiles: 產生 Eclipse CDT 4.0 專案檔。

    Eclipse 的專案檔將會在頂層目錄中建立，並且會將連結資源連結到每個具有包含 PROJECT() 呼叫的 CMakeLists.txt 檔案的子目錄。此外，makefiles 的階層會產生到建置樹狀結構中。 適當的 make 程式可以透過預設的 make 目標來建置專案。 也提供了「make install」目標。

  • Eclipse CDT4 - NMake Makefiles: 產生 Eclipse CDT 4.0 專案檔。

    Eclipse 的專案檔將會在頂層目錄中建立，並且會將連結資源連結到每個具有包含 PROJECT() 呼叫的 CMakeLists.txt 檔案的子目錄。此外，makefiles 的階層會產生到建置樹狀結構中。 適當的 make 程式可以透過預設的 make 目標來建置專案。 也提供了「make install」目標。

  • Eclipse CDT4 - Unix Makefiles: 產生 Eclipse CDT 4.0 專案檔。

    Eclipse 的專案檔將會在頂層目錄中建立，並且會將連結資源連結到每個具有包含 PROJECT() 呼叫的 CMakeLists.txt 檔案的子目錄。此外，makefiles 的階層會產生到建置樹狀結構中。 適當的 make 程式可以透過預設的 make 目標來建置專案。 也提供了「make install」目標。

命令

  • add_custom_command: 將自訂建置規則新增到產生的建置系統。

    add_custom_command 有兩個主要簽章。第一個簽章用於新增自訂命令以產生輸出。

      add_custom_command(OUTPUT output1 [output2 ...]
                         COMMAND command1 [ARGS] [args1...]
                         [COMMAND command2 [ARGS] [args2...] ...]
                         [MAIN_DEPENDENCY depend]
                         [DEPENDS [depends...]]
                         [IMPLICIT_DEPENDS <lang1> depend1 ...]
                         [WORKING_DIRECTORY dir]
                         [COMMENT comment] [VERBATIM] [APPEND])

    這會定義一個新的命令，可以在建置過程中執行。 名稱的輸出應該列為要為其產生輸出的目標中的來源檔。 如果輸出名稱是相對路徑，它將會被解譯為相對於目前來源目錄的建置樹狀結構目錄。 請注意，MAIN_DEPENDENCY 是完全選用的，並且用作向 Visual Studio 建議自訂命令的掛載位置。 以 makefile 的術語來說，這會建立以下形式的新目標

      OUTPUT: MAIN_DEPENDENCY DEPENDS
              COMMAND

    如果指定多個命令，它們將會依序執行。 可選的 ARGS 引數用於向後相容性，將會被忽略。

    第二個簽章會將自訂命令新增到目標，例如程式庫或可執行檔。 這對於在建置目標之前或之後執行操作很有用。 該命令會成為目標的一部分，並且只會在建置目標本身時執行。 如果已建置目標，該命令將不會執行。

      add_custom_command(TARGET target
                         PRE_BUILD | PRE_LINK | POST_BUILD
                         COMMAND command1 [ARGS] [args1...]
                         [COMMAND command2 [ARGS] [args2...] ...]
                         [WORKING_DIRECTORY dir]
                         [COMMENT comment] [VERBATIM])

    這會定義一個新的命令，該命令將與建置指定的目標相關聯。 何時發生命令取決於指定以下哪一個

      PRE_BUILD - run before all other dependencies
      PRE_LINK - run after other dependencies
      POST_BUILD - run after the target has been built

    請注意，只有 Visual Studio 7 或更新版本才支援 PRE_BUILD 選項。 對於所有其他產生器，PRE_BUILD 將會被視為 PRE_LINK。

    如果指定 WORKING_DIRECTORY，命令將會在指定的目錄中執行。 如果設定 COMMENT，則該值將會在建置時顯示為訊息，然後再執行命令。 如果指定 APPEND，則 COMMAND 和 DEPENDS 選項值會附加到指定的第一個輸出的自訂命令。 必須已經先前使用相同的輸出呼叫過此命令。 當給定 APPEND 時，目前會忽略 COMMENT、WORKING_DIRECTORY 和 MAIN_DEPENDENCY 選項，但將來可能會使用它們。

    如果給定 VERBATIM，則無論使用何種建置工具，命令的所有參數都將完全按照指定的方式傳遞。請注意，在 ADD_CUSTOM_TARGET 甚至看到這些參數之前，CMake 語言處理器仍會使用一層跳脫字元。建議使用 VERBATIM，因為它可以啟用正確的行為。當未給定 VERBATIM 時，其行為會因平台而異。未來可能會預設啟用 VERBATIM。它之所以成為選項，唯一的原因是為了保持與舊 CMake 程式碼的相容性。

    如果自訂命令的輸出實際上不是在磁碟上建立為檔案，則應使用 SET_SOURCE_FILES_PROPERTIES 將其標記為 SYMBOLIC。

    IMPLICIT_DEPENDS 選項要求掃描輸入檔案的隱含相依性。給定的語言指定應使用其對應的相依性掃描器的程式設計語言。目前僅支援 C 和 CXX 語言掃描器。從掃描中發現的相依性會在建置時新增至自訂命令的相依性。請注意，IMPLICIT_DEPENDS 選項目前僅支援 Makefile 產生器，其他產生器將會忽略此選項。

    如果 COMMAND 指定可執行目標 (由 ADD_EXECUTABLE 建立)，則會自動取代為建置時建立的可執行檔位置。此外，還會新增目標層級相依性，以便在任何使用此自訂命令的目標之前建置可執行目標。然而，這不會新增檔案層級相依性，該相依性會導致每當重新編譯可執行檔時重新執行自訂命令。

    如果 DEPENDS 指定任何目標 (由 ADD_* 命令建立)，則會建立目標層級相依性，以確保在任何使用此自訂命令的目標之前建置該目標。此外，如果目標是可執行檔或程式庫，則會建立檔案層級相依性，以導致每當重新編譯目標時重新執行自訂命令。

  • add_custom_target: 新增一個沒有輸出的目標，因此它將始終被建置。
      add_custom_target(Name [ALL] [command1 [args1...]]
                        [COMMAND command2 [args2...] ...]
                        [DEPENDS depend depend depend ... ]
                        [WORKING_DIRECTORY dir]
                        [COMMENT comment] [VERBATIM]
                        [SOURCES src1 [src2...]])

    新增一個具有給定名稱的目標，該目標會執行給定的命令。該目標沒有輸出檔案，並且始終被視為過期，即使命令嘗試建立一個與目標名稱相同的檔案。請使用 ADD_CUSTOM_COMMAND 來產生具有相依性的檔案。預設情況下，沒有任何項目依賴自訂目標。使用 ADD_DEPENDENCIES 新增與其他目標之間的相依性。如果指定了 ALL 選項，則表示應將此目標新增至預設建置目標，以便每次都會執行 (該命令不能被呼叫為 ALL)。命令和引數是選用的，如果未指定，則會建立一個空的目標。如果設定了 WORKING_DIRECTORY，則會在該目錄中執行命令。如果設定了 COMMENT，則會在建置時執行命令之前將該值顯示為訊息。以 DEPENDS 引數列出的相依性可能會參考檔案以及使用 ADD_CUSTOM_COMMAND 建立的自訂命令的輸出。

    如果給定 VERBATIM，則無論使用何種建置工具，命令的所有參數都將完全按照指定的方式傳遞。請注意，在 add_custom_target 甚至看到這些參數之前，CMake 語言處理器仍會使用一層跳脫字元。建議使用 VERBATIM，因為它可以啟用正確的行為。當未給定 VERBATIM 時，其行為會因平台而異。未來可能會預設啟用 VERBATIM。它之所以成為選項，唯一的原因是為了保持與舊 CMake 程式碼的相容性。

    SOURCES 選項指定要包含在自訂目標中的其他來源檔案。指定的來源檔案將新增至 IDE 專案檔案中，以方便編輯，即使它們沒有建置規則。

  • add_definitions: 將 -D 定義旗標新增至來源檔案的編譯。
      add_definitions(-DFOO -DBAR ...)

    為目前目錄及以下目錄中的來源新增編譯器命令列的旗標。此命令可用於新增任何旗標，但它最初的目的是新增前處理器定義。開頭為 -D 或 /D 且看起來像前處理器定義的旗標會自動新增至目前目錄的 COMPILE_DEFINITIONS 屬性。具有非簡單值定義可能會保留在旗標集中，而不是為了向後相容性而進行轉換。有關將前處理器定義新增至特定範圍和設定的詳細資訊，請參閱目錄、目標和來源檔案 COMPILE_DEFINITIONS 屬性的文件。

  • add_dependencies: 在頂層目標之間新增相依性。
      add_dependencies(target-name depend-target1
                       depend-target2 ...)

    使頂層目標依賴其他頂層目標。頂層目標是由 ADD_EXECUTABLE、ADD_LIBRARY 或 ADD_CUSTOM_TARGET 建立的目標。使用此命令新增相依性可用於確保在建置另一個目標之前先建置一個目標。有關在自訂規則中新增檔案層級相依性，請參閱 ADD_CUSTOM_TARGET 和 ADD_CUSTOM_COMMAND 的 DEPENDS 選項。有關將檔案層級相依性新增至物件檔案，請參閱 SET_SOURCE_FILES_PROPERTIES 中的 OBJECT_DEPENDS 選項。

  • add_executable: 使用指定的來源檔案將可執行檔新增至專案。
      add_executable(<name> [WIN32] [MACOSX_BUNDLE] [EXCLUDE_FROM_ALL]
                     source1 source2 ... sourceN)

    新增一個名為 <name> 的可執行目標，該目標將從命令呼叫中列出的來源檔案進行建置。<name> 對應於邏輯目標名稱，並且在專案中必須是全域唯一的。所建置可執行檔的實際檔案名稱是根據原生平台的慣例建構的 (例如 <name>.exe 或僅 <name>)。

    預設情況下，可執行檔將建立在與呼叫命令的來源樹目錄對應的建置樹目錄中。請參閱 RUNTIME_OUTPUT_DIRECTORY 目標屬性的文件以變更此位置。請參閱 OUTPUT_NAME 目標屬性的文件以變更最終檔案名稱的 <name> 部分。

    如果給定 WIN32，則會在建立的目標上設定 WIN32_EXECUTABLE 屬性。有關詳細資訊，請參閱該目標屬性的文件。

    如果給定 MACOSX_BUNDLE，則會在建立的目標上設定對應的屬性。有關詳細資訊，請參閱 MACOSX_BUNDLE 目標屬性的文件。

    如果給定 EXCLUDE_FROM_ALL，則會在建立的目標上設定對應的屬性。有關詳細資訊，請參閱 EXCLUDE_FROM_ALL 目標屬性的文件。

    add_executable 命令也可以使用此簽名建立 IMPORTED 可執行目標

      add_executable(<name> IMPORTED)

    IMPORTED 可執行目標引用位於專案外部的可執行檔。不會產生任何建置它的規則。目標名稱在其建立的目錄及其以下目錄中具有範圍。它可以像在專案中建置的任何目標一樣被引用。IMPORTED 可執行檔對於從 add_custom_command 等命令進行方便的引用非常有用。有關導入的可執行檔的詳細資訊，請透過設定以「IMPORTED_」開頭的屬性來指定。最重要的屬性是 IMPORTED_LOCATION (及其每個組態版本 IMPORTED_LOCATION_<CONFIG>)，它指定磁碟上主要可執行檔的位置。有關詳細資訊，請參閱 IMPORTED_* 屬性的文件。

  • add_library: 使用指定的來源檔案將程式庫新增至專案。
      add_library(<name> [STATIC | SHARED | MODULE] [EXCLUDE_FROM_ALL]
                  source1 source2 ... sourceN)

    新增一個名為 <name> 的程式庫目標，該目標將從命令呼叫中列出的來源檔案進行建置。<name> 對應於邏輯目標名稱，並且在專案中必須是全域唯一的。所建置程式庫的實際檔案名稱是根據原生平台的慣例建構的 (例如 lib<name>.a 或 <name>.lib)。

    可以給定 STATIC、SHARED 或 MODULE 來指定要建立的程式庫類型。STATIC 程式庫是物件檔案的封存，用於連結其他目標時使用。SHARED 程式庫會動態連結，並在執行階段載入。MODULE 程式庫是不連結到其他目標的插件，但可以在執行階段使用類似 dlopen 的功能動態載入。如果未明確給定任何類型，則類型為 STATIC 或 SHARED，具體取決於變數 BUILD_SHARED_LIBS 的目前值是否為 true。

    預設情況下，程式庫檔案將建立在與呼叫命令的來源樹目錄對應的建置樹目錄中。請參閱 ARCHIVE_OUTPUT_DIRECTORY、LIBRARY_OUTPUT_DIRECTORY 和 RUNTIME_OUTPUT_DIRECTORY 目標屬性的文件以變更此位置。請參閱 OUTPUT_NAME 目標屬性的文件以變更最終檔案名稱的 <name> 部分。

    如果給定 EXCLUDE_FROM_ALL，則會在建立的目標上設定對應的屬性。有關詳細資訊，請參閱 EXCLUDE_FROM_ALL 目標屬性的文件。

    add_library 命令也可以使用此簽名建立 IMPORTED 程式庫目標

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

    IMPORTED 程式庫目標引用位於專案外部的程式庫檔案。不會產生任何建置它的規則。目標名稱在其建立的目錄及其以下目錄中具有範圍。它可以像在專案中建置的任何目標一樣被引用。IMPORTED 程式庫對於從 target_link_libraries 等命令進行方便的引用非常有用。有關導入的程式庫的詳細資訊，請透過設定以「IMPORTED_」開頭的屬性來指定。最重要的屬性是 IMPORTED_LOCATION (及其每個組態版本 IMPORTED_LOCATION_<CONFIG>)，它指定磁碟上主要程式庫檔案的位置。有關詳細資訊，請參閱 IMPORTED_* 屬性的文件。

  • add_subdirectory: 將子目錄新增至建置。
      add_subdirectory(source_dir [binary_dir] 
                       [EXCLUDE_FROM_ALL])

    將子目錄新增至建置。source_dir 指定來源 CmakeLists.txt 和程式碼檔案所在的目錄。如果它是相對路徑，則相對於目前目錄 (典型用法) 進行評估，但它也可以是絕對路徑。binary_dir 指定放置輸出檔案的目錄。如果它是相對路徑，則相對於目前的輸出目錄進行評估，但它也可以是絕對路徑。如果未指定 binary_dir，則將使用 source_dir 的值 (在展開任何相對路徑之前) (典型用法)。CMakeLists.txt 在指定的來源目錄中的檔案會由 CMake 立即處理，然後才繼續處理目前輸入檔案中的此命令之後的內容。

    如果提供了 EXCLUDE_FROM_ALL 引數，則預設情況下，子目錄中的目標將不會包含在父目錄的 ALL 目標中，並且會從 IDE 專案檔案中排除。使用者必須明確地建置子目錄中的目標。這適用於子目錄包含專案中一個有用但非必要的部分時，例如一組範例。通常，子目錄應包含自己的 project() 命令呼叫，以便在子目錄中產生完整的建置系統 (例如 VS IDE 解決方案檔案)。請注意，目標間相依性會取代此排除。如果父專案建置的目標依賴子目錄中的目標，則被依賴目標將包含在父專案建置系統中以滿足相依性。

  • add_test: 使用指定的引數將測試新增至專案。
      add_test(testname Exename arg1 arg2 ...)

    如果已執行 ENABLE_TESTING 命令，則此命令會在目前目錄中新增測試目標。如果尚未執行 ENABLE_TESTING，則此命令不執行任何操作。測試是由測試子系統透過執行 Exename 和指定的引數來執行的。Exename 可以是由此專案建置的可執行檔，也可以是系統上的任意可執行檔 (例如 tclsh)。測試將在目前工作目錄設定為二進制樹中的 CMakeList.txt 檔案對應的目錄時執行。

  • aux_source_directory: 尋找目錄中的所有來源檔案。
      aux_source_directory(<dir> <variable>)

    收集指定目錄中所有來源檔案的名稱，並將該清單儲存在提供的 <variable> 中。此命令旨在供使用明確範本具現化的專案使用。範本具現化檔案可以儲存在「Templates」子目錄中，並使用此命令自動收集，以避免手動列出所有具現化。

    使用這個命令來避免為函式庫或可執行目標寫入原始檔清單是很誘人的。雖然這似乎可行，但 CMake 無法產生一個知道何時添加新原始檔的建置系統。通常，產生的建置系統知道何時需要重新執行 CMake，因為 CMakeLists.txt 檔案被修改以加入新的原始檔。當原始檔只是被添加到目錄而沒有修改此檔案時，就必須手動重新執行 CMake 以產生包含新檔案的建置系統。

  • break：從封閉的 foreach 或 while 迴圈中跳脫。
      break()

    從封閉的 foreach 迴圈或 while 迴圈中跳脫

  • build_command：取得將建置此專案的命令列。
      build_command(<variable> <makecommand>)

    將指定的 <variable> 設定為一個字串，其中包含使用 <makecommand> 給定的建置工具，從建置樹的根目錄建置此專案的命令。 <makecommand> 應該是 msdev、nmake、make 或其中一個終端使用者建置工具。這對於配置測試系統很有用。

  • cmake_minimum_required：設定專案所需的最低 CMake 版本。
      cmake_minimum_required(VERSION major[.minor[.patch]]
                             [FATAL_ERROR])

    如果目前的 CMake 版本低於所需版本，它將停止處理專案並回報錯誤。當指定的版本高於 2.4 時，該命令會隱式調用

      cmake_policy(VERSION major[.minor[.patch]])

    這會將 cmake 政策版本級別設定為指定的版本。當給定的版本為 2.4 或更低時，該命令會隱式調用

      cmake_policy(VERSION 2.4)

    這會啟用 CMake 2.4 及更低版本的相容性功能。

    FATAL_ERROR 選項被接受，但 CMake 2.6 及更高版本會忽略它。 應該指定它，以便 CMake 2.4 及更低版本會因錯誤而失敗，而不僅僅是警告。

  • cmake_policy：管理 CMake 政策設定。

    隨著 CMake 的發展，有時需要變更現有的行為，以修復錯誤或改進現有功能的實作。 CMake 政策機制旨在協助保持現有的專案在 CMake 新版本引入行為變更時繼續建置。每個新政策（行為變更）都會被賦予一個「CMP<NNNN>」形式的識別符號，其中「<NNNN>」是一個整數索引。每個政策的相關文件描述了舊的行為和新的行為，以及引入該政策的原因。專案可以設定每個政策來選擇所需的行為。當 CMake 需要知道要使用哪個行為時，它會檢查專案指定的設定。如果沒有可用的設定，則會採用舊的行為，並產生一個警告，要求設定該政策。

    cmake_policy 命令用於將政策設定為舊的或新的行為。雖然支援個別設定政策，但我們鼓勵專案根據 CMake 版本設定政策。

      cmake_policy(VERSION major.minor[.patch])

    指定目前的 CMake 清單檔案是為給定的 CMake 版本編寫的。在指定版本或更早版本中引入的所有政策都將被設定為使用新的行為。在指定版本之後引入的所有政策都將被重設為使用舊的行為並發出警告。這實際上要求截至給定 CMake 版本時首選的行為，並告訴較新的 CMake 版本警告它們的新政策。指定的政策版本必須至少為 2.4，否則該命令將回報錯誤。為了獲得支援 2.4 之前版本的相容性功能，請參閱政策 CMP0001 的文件。

      cmake_policy(SET CMP<NNNN> NEW)
      cmake_policy(SET CMP<NNNN> OLD)

    告訴 CMake 對給定的政策使用舊的或新的行為。依賴於給定政策舊行為的專案可以透過將政策狀態設定為 OLD 來消除政策警告。或者，可以修復專案以使用新行為，並將政策狀態設定為 NEW。

      cmake_policy(GET CMP<NNNN> <variable>)

    檢查給定的政策是否設定為舊的或新的行為。如果已設定政策，則輸出變數值將為「OLD」或「NEW」，否則為空。

    CMake 將政策設定保留在堆疊上，因此 cmake_policy 命令所做的變更僅影響堆疊的頂端。每個子目錄都會自動管理政策堆疊上的新條目，以保護其父層和同層。CMake 還會為 include() 和 find_package() 命令載入的腳本管理一個新條目，但使用 NO_POLICY_SCOPE 選項調用時除外（另請參閱政策 CMP0011）。cmake_policy 命令提供了一個介面來管理政策堆疊上的自訂條目

      cmake_policy(PUSH)
      cmake_policy(POP)

    每個 PUSH 都必須有一個對應的 POP，以清除任何變更。這對於暫時變更政策設定很有用。

    函式和巨集會在建立時記錄政策設定，並在調用時使用預先記錄的政策。如果函式或巨集實作設定了政策，則變更會自動向上傳播到呼叫者，直到它們到達最接近的巢狀政策堆疊條目。

  • configure_file：將檔案複製到另一個位置並修改其內容。
      configure_file(InputFile OutputFile
                     [COPYONLY] [ESCAPE_QUOTES] [@ONLY])

    輸入和輸出檔案必須具有完整路徑。此命令會將輸入檔案中任何以 ${VAR} 或 @VAR@ 參照的變數，替換為 CMake 確定的值。如果未定義變數，則將其替換為空。如果指定了 COPYONLY，則不會發生變數展開。如果指定了 ESCAPE_QUOTES，則任何被替換的引號都將會是 C 風格的逸出。該檔案將使用 CMake 變數的目前值進行配置。如果指定了 @ONLY，則只會替換 @VAR@ 形式的變數，而 ${VAR} 會被忽略。這對於配置使用 ${VAR} 的腳本很有用。 任何出現的 #cmakedefine VAR 都會被替換為 #define VAR 或 /* #undef VAR */，具體取決於 CMake 中 VAR 的設定。

  • create_test_sourcelist：建立測試驅動程式和原始碼清單，以建置測試程式。
      create_test_sourcelist(sourceListName driverName
                             test1 test2 test3
                             EXTRA_INCLUDE include.h
                             FUNCTION function)

    測試驅動程式是一個將許多小型測試連結到單個可執行檔中的程式。當使用大型函式庫建置靜態可執行檔以縮小總需求大小時，這很有用。建置測試驅動程式所需的原始檔清單將在 sourceListName 中。 DriverName 是測試驅動程式程式的名稱。其餘的參數包含一個測試原始檔清單，可以用分號分隔。每個測試原始檔都應該在其中包含一個函式，該函式與沒有副檔名的檔案名稱相同（foo.cxx 應該包含 int foo(int, char*[]);）。DriverName 將能夠在命令列上按名稱調用每個測試。如果指定了 EXTRA_INCLUDE，則下一個參數將包含在產生的檔案中。如果指定了 FUNCTION，則下一個參數會被視為函式名稱，該函式會被傳遞指向 ac 和 av 的指標。這可用於為每個測試新增額外的命令列處理。 可以設定 CMake 變數 CMAKE_TESTDRIVER_BEFORE_TESTMAIN，以在調用測試主要函式之前直接放置程式碼。 可以設定 CMAKE_TESTDRIVER_AFTER_TESTMAIN，以在調用測試主要函式之後直接放置程式碼。

  • define_property：定義並記錄自訂屬性。
      define_property(<GLOBAL | DIRECTORY | TARGET | SOURCE |
                       TEST | VARIABLE | CACHED_VARIABLE>
                       PROPERTY <name> [INHERITED]
                       BRIEF_DOCS <brief-doc>
                       FULL_DOCS <full-doc>)

    在範圍中定義一個屬性，以用於 set_property 和 get_property 命令。這主要用於將文件與可以使用 get_property 命令擷取的屬性名稱關聯。第一個參數決定應使用屬性的範圍類型。它必須是下列其中之一

      GLOBAL    = associated with the global namespace
      DIRECTORY = associated with one directory
      TARGET    = associated with one target
      SOURCE    = associated with one source file
      TEST      = associated with a test named with add_test command
      VARIABLE  = documents a CMake language variable
      CACHED_VARIABLE = documents a CMake cache variable

    請注意，與 set_property 和 get_property 不同，不需要給出實際範圍；僅範圍的類型很重要。

    必要的 PROPERTY 選項之後立即接著要定義的屬性名稱。

    如果 INHERITED 選項，則 get_property 命令將鏈接到下一個較高的範圍，當要求的屬性未在給定命令的範圍中設定時。DIRECTORY 範圍鏈接到 GLOBAL。TARGET、SOURCE 和 TEST 鏈接到 DIRECTORY。

    BRIEF_DOCS 和 FULL_DOCS 選項之後接著要與屬性關聯的字串，作為其簡短和完整的文件。 get_property 命令的相應選項將會擷取該文件。

  • else：開始 if 區塊的 else 部分。
      else(expression)

    請參閱 if 命令。

  • elseif：開始 if 區塊的 elseif 部分。
      elseif(expression)

    請參閱 if 命令。

  • enable_language：啟用語言 (CXX/C/Fortran/等等)
      enable_language(languageName [OPTIONAL] )

    此命令在 CMake 中啟用對指定語言的支援。這與 project 命令相同，但不建立 project 命令建立的任何額外變數。例如，語言有 CXX、C、Fortran。

    如果使用 OPTIONAL，請使用 CMAKE_<languageName>_COMPILER_WORKS 變數來檢查是否已成功啟用該語言。

  • enable_testing：啟用目前目錄和以下目錄的測試。
      enable_testing()

    啟用此目錄和以下目錄的測試。另請參閱 add_test 命令。請注意，ctest 期望在建置目錄根目錄中找到測試檔案。因此，此命令應在原始碼目錄根目錄中。

  • endforeach：結束 FOREACH 區塊中的命令清單。
      endforeach(expression)

    請參閱 FOREACH 命令。

  • endfunction：結束函式區塊中的命令清單。
      endfunction(expression)

    請參閱 function 命令。

  • endif：結束 if 區塊中的命令清單。
      endif(expression)

    請參閱 if 命令。

  • endmacro：結束巨集區塊中的命令清單。
      endmacro(expression)

    請參閱 macro 命令。

  • endwhile：結束 while 區塊中的命令清單。
      endwhile(expression)

    請參閱 while 命令。

  • execute_process：執行一個或多個子程序。
      execute_process(COMMAND <cmd1> [args1...]]
                      [COMMAND <cmd2> [args2...] [...]]
                      [WORKING_DIRECTORY <directory>]
                      [TIMEOUT <seconds>]
                      [RESULT_VARIABLE <variable>]
                      [OUTPUT_VARIABLE <variable>]
                      [ERROR_VARIABLE <variable>]
                      [INPUT_FILE <file>]
                      [OUTPUT_FILE <file>]
                      [ERROR_FILE <file>]
                      [OUTPUT_QUIET]
                      [ERROR_QUIET]
                      [OUTPUT_STRIP_TRAILING_WHITESPACE]
                      [ERROR_STRIP_TRAILING_WHITESPACE])

    使用每個程序的標準輸出，透過管道傳送到下一個程序的標準輸入來執行給定的一個或多個命令序列。所有程序使用單個標準錯誤管道。如果給定了 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 的較新且更強大的版本，但為了保持相容性，保留了舊命令。

  • export：從建置樹匯出目標，供外部專案使用。
      export(TARGETS [target1 [target2 [...]]] [NAMESPACE <namespace>]
             [APPEND] FILE <filename>)

    建立一個檔案 <filename>，外部專案可以包含該檔案，以從目前專案的建置樹中匯入目標。這在交叉編譯期間很有用，可以在一個專案中建置可在主機平台上執行的實用可執行檔，然後將它們匯入到另一個為目標平台編譯的專案中。如果給定了 NAMESPACE 選項，則 <namespace> 字串將會附加到寫入檔案的所有目標名稱的前面。如果給定了 APPEND 選項，則產生的程式碼將附加到檔案中，而不是覆寫它。如果匯出中包含函式庫目標，但未包含其連結的目標，則該行為未指定。

    此命令建立的檔案特定於建置樹狀結構，絕不應安裝。請參閱 install(EXPORT) 命令，以匯出安裝樹狀結構中的目標。

  • file：檔案操作命令。
      file(WRITE filename "message to write"... )
      file(APPEND filename "message to write"... )
      file(READ filename variable [LIMIT numBytes] [OFFSET offset] [HEX])
      file(STRINGS filename variable [LIMIT_COUNT num]
           [LIMIT_INPUT numBytes] [LIMIT_OUTPUT numBytes]
           [LENGTH_MINIMUM numBytes] [LENGTH_MAXIMUM numBytes]
           [NEWLINE_CONSUME] [REGEX regex]
           [NO_HEX_CONVERSION])
      file(GLOB variable [RELATIVE path] [globbing expressions]...)
      file(GLOB_RECURSE variable [RELATIVE path] 
           [FOLLOW_SYMLINKS] [globbing expressions]...)
      file(REMOVE [file1 ...])
      file(REMOVE_RECURSE [file1 ...])
      file(MAKE_DIRECTORY [directory1 directory2 ...])
      file(RELATIVE_PATH variable directory file)
      file(TO_CMAKE_PATH path result)
      file(TO_NATIVE_PATH path result)
      file(DOWNLOAD url file [TIMEOUT timeout] [STATUS status] [LOG log])

    WRITE 會將訊息寫入名為 'filename' 的檔案。如果檔案已存在，則會覆寫該檔案；如果檔案不存在，則會建立該檔案。

    APPEND 會將訊息寫入檔案，與 WRITE 相同，但會將訊息附加到檔案末尾

    READ 會讀取檔案的內容，並將其儲存在變數中。它會從指定的偏移量開始讀取，最多讀取 numBytes 個位元組。如果提供參數 HEX，則二進位資料會轉換為十六進位表示法，並儲存在變數中。

    STRINGS 會從檔案中解析 ASCII 字串清單，並將其儲存在變數中。檔案中的二進位資料會被忽略。歸位 (CR) 字元會被忽略。它也適用於 Intel Hex 和 Motorola S-record 檔案，讀取時會自動轉換為二進位格式。使用 NO_HEX_CONVERSION 停用此功能。

    LIMIT_COUNT 設定要傳回的最大字串數。LIMIT_INPUT 設定要從輸入檔案讀取的最大位元組數。LIMIT_OUTPUT 設定要儲存在輸出變數中的最大位元組數。LENGTH_MINIMUM 設定要傳回的字串的最小長度。較短的字串會被忽略。LENGTH_MAXIMUM 設定要傳回的字串的最大長度。較長的字串會分割成不超過最大長度的字串。NEWLINE_CONSUME 允許將換行符號包含在字串中，而不是終止它們。

    REGEX 指定字串必須符合才能傳回的正規表示式。典型用法

      file(STRINGS myfile.txt myfile)

    會在變數 "myfile" 中儲存一個清單，其中每個項目都是輸入檔案中的一行。

    GLOB 會產生符合 globbing 表達式的所有檔案清單，並將其儲存在變數中。Globbing 表達式與正規表示式類似，但簡單得多。如果為表達式指定了 RELATIVE 旗標，則結果將以相對於給定路徑的相對路徑傳回。

    Globbing 表達式的範例包括

       *.cxx      - match all files with extension cxx
       *.vt?      - match all files with extension vta,...,vtz
       f[3-5].txt - match files f3.txt, f4.txt, f5.txt

    GLOB_RECURSE 會產生與一般 GLOB 類似的清單，但會遍歷比對目錄的所有子目錄並比對檔案。只有在提供 FOLLOW_SYMLINKS 或 cmake 原則 CMP0009 未設定為 NEW 時，才會遍歷符號連結的子目錄。如需詳細資訊，請參閱 cmake --help-policy CMP0009。

    遞迴 globbing 的範例包括

       /dir/*.py  - match all python files in /dir and subdirectories

    MAKE_DIRECTORY 會建立給定的目錄，即使其父目錄尚不存在也是如此

    REMOVE 會移除給定的檔案，包括子目錄中的檔案

    REMOVE_RECURSE 會移除給定的檔案和目錄，包括非空目錄

    RELATIVE_PATH 會判斷從目錄到給定檔案的相對路徑。

    TO_CMAKE_PATH 會將路徑轉換為具有 unix / 的 cmake 樣式路徑。輸入可以是單一路徑，也可以是 "$ENV{PATH}" 之類的系統路徑。請注意，ENV 呼叫周圍的雙引號 TO_CMAKE_PATH 只接受一個參數。

    TO_NATIVE_PATH 的運作方式與 TO_CMAKE_PATH 相同，但會將 cmake 樣式路徑轉換為原生路徑樣式，Windows 使用 \，UNIX 使用 /。

    DOWNLOAD 會將給定的 URL 下載到給定的檔案。如果指定 LOG var，則會將下載記錄放在 var 中。如果指定 STATUS var，則會將操作的狀態放在 var 中。狀態以長度為 2 的清單傳回。第一個元素是操作的數值傳回值，第二個元素是錯誤的字串值。數值錯誤為 0 表示操作中沒有錯誤。如果指定 TIMEOUT time，則操作會在 time 秒後逾時，time 可以指定為浮點數。

  • find_file：尋找檔案的完整路徑。
       find_path(<VAR> name1 [path1 path2 ...])

    這是命令的簡短簽名，在許多情況下都足夠使用。它與 find_path(<VAR> name1 [PATHS path1 path2 ...]) 相同

       find_path(
                 <VAR>
                 name | NAMES name1 [name2 ...]
                 [HINTS path1 [path2 ... ENV var]]
                 [PATHS path1 [path2 ... ENV var]]
                 [PATH_SUFFIXES suffix1 [suffix2 ...]]
                 [DOC "cache documentation string"]
                 [NO_DEFAULT_PATH]
                 [NO_CMAKE_ENVIRONMENT_PATH]
                 [NO_CMAKE_PATH]
                 [NO_SYSTEM_ENVIRONMENT_PATH]
                 [NO_CMAKE_SYSTEM_PATH]
                 [CMAKE_FIND_ROOT_PATH_BOTH |
                  ONLY_CMAKE_FIND_ROOT_PATH |
                  NO_CMAKE_FIND_ROOT_PATH]
                )

    此命令用於尋找指定檔案的完整路徑。會建立一個名為 <VAR> 的快取項目，以儲存此命令的結果。如果找到檔案的完整路徑，則會將結果儲存在變數中，並且除非清除該變數，否則不會重複搜尋。如果找不到任何內容，則結果將為 <VAR>-NOTFOUND，並且下次以相同的變數叫用 find_path 時，會再次嘗試搜尋。要搜尋的檔案完整路徑名稱由 NAMES 引數之後列出的名稱指定。可以在 PATHS 引數之後指定其他搜尋位置。如果在 HINTS 或 PATHS 區段中找到 ENV var，則會讀取環境變數 var，並從系統環境變數轉換為 cmake 樣式的路徑清單。例如，ENV PATH 會是一種列出系統路徑變數的方式。DOC 之後的引數將用於快取中的文件字串。PATH_SUFFIXES 會指定要檢查的每個搜尋路徑下方的其他子目錄。

    如果指定 NO_DEFAULT_PATH，則不會將其他路徑新增至搜尋。如果未指定 NO_DEFAULT_PATH，則搜尋程序如下

    1. 搜尋 cmake 特定快取變數中指定的路徑。這些變數旨在透過 -DVAR=value 在命令列上使用。如果傳遞 NO_CMAKE_PATH，則可以略過此步驟。

       <prefix>/include for each <prefix> in CMAKE_PREFIX_PATH
       CMAKE_INCLUDE_PATH
       CMAKE_FRAMEWORK_PATH

    2. 搜尋 cmake 特定環境變數中指定的路徑。這些變數旨在使用者 shell 設定中設定。如果傳遞 NO_CMAKE_ENVIRONMENT_PATH，則可以略過此步驟。

       <prefix>/include for each <prefix> in CMAKE_PREFIX_PATH
       CMAKE_INCLUDE_PATH
       CMAKE_FRAMEWORK_PATH

    3. 搜尋 HINTS 選項指定的路徑。這些路徑應該是由系統內省計算的路徑，例如已找到的另一個項目的位置提供的提示。硬式編碼的猜測應該使用 PATHS 選項指定。

    4. 搜尋標準系統環境變數。如果 NO_SYSTEM_ENVIRONMENT_PATH 是一個引數，則可以略過此步驟。

       PATH
       INCLUDE

    5. 搜尋在目前系統的平台檔案中定義的 cmake 變數。如果傳遞 NO_CMAKE_SYSTEM_PATH，則可以略過此步驟。

       <prefix>/include for each <prefix> in CMAKE_SYSTEM_PREFIX_PATH
       CMAKE_SYSTEM_INCLUDE_PATH
       CMAKE_SYSTEM_FRAMEWORK_PATH

    6. 搜尋 PATHS 選項或命令簡短版本中指定的路徑。這些通常是硬式編碼的猜測。

    在 Darwin 或支援 OS X Frameworks 的系統上，cmake 變數 CMAKE_FIND_FRAMEWORK 可以設定為空白或下列其中之一

       "FIRST"  - Try to find frameworks before standard
                  libraries or headers. This is the default on Darwin.
       "LAST"   - Try to find frameworks after standard
                  libraries or headers.
       "ONLY"   - Only try to find frameworks.
       "NEVER". - Never try to find frameworks.

    在 Darwin 或支援 OS X Application Bundles 的系統上，cmake 變數 CMAKE_FIND_APPBUNDLE 可以設定為空白或下列其中之一

       "FIRST"  - Try to find application bundles before standard
                  programs. This is the default on Darwin.
       "LAST"   - Try to find application bundles after standard
                  programs.
       "ONLY"   - Only try to find application bundles.
       "NEVER". - Never try to find 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，則只會搜尋重新植根的目錄。

    預設的搜尋順序旨在針對常見的使用案例，從最特定到最不特定。專案可以透過多次呼叫命令並使用 NO_* 選項來覆寫順序

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

    一旦其中一個呼叫成功，就會設定結果變數並儲存在快取中，以便任何呼叫都不會再次搜尋。

  • find_library：尋找程式庫。
       find_library(<VAR> name1 [path1 path2 ...])

    這是命令的簡短簽名，在許多情況下都足夠使用。它與 find_library(<VAR> name1 [PATHS path1 path2 ...]) 相同

       find_library(
                 <VAR>
                 name | NAMES name1 [name2 ...]
                 [HINTS path1 [path2 ... ENV var]]
                 [PATHS path1 [path2 ... ENV var]]
                 [PATH_SUFFIXES suffix1 [suffix2 ...]]
                 [DOC "cache documentation string"]
                 [NO_DEFAULT_PATH]
                 [NO_CMAKE_ENVIRONMENT_PATH]
                 [NO_CMAKE_PATH]
                 [NO_SYSTEM_ENVIRONMENT_PATH]
                 [NO_CMAKE_SYSTEM_PATH]
                 [CMAKE_FIND_ROOT_PATH_BOTH |
                  ONLY_CMAKE_FIND_ROOT_PATH |
                  NO_CMAKE_FIND_ROOT_PATH]
                )

    此命令用於尋找程式庫。會建立一個名為 <VAR> 的快取項目，以儲存此命令的結果。如果找到程式庫，則會將結果儲存在變數中，並且除非清除該變數，否則不會重複搜尋。如果找不到任何內容，則結果將為 <VAR>-NOTFOUND，並且下次以相同的變數叫用 find_library 時，會再次嘗試搜尋。要搜尋的程式庫名稱由 NAMES 引數之後列出的名稱指定。可以在 PATHS 引數之後指定其他搜尋位置。如果在 HINTS 或 PATHS 區段中找到 ENV var，則會讀取環境變數 var，並從系統環境變數轉換為 cmake 樣式的路徑清單。例如，ENV PATH 會是一種列出系統路徑變數的方式。DOC 之後的引數將用於快取中的文件字串。PATH_SUFFIXES 會指定要檢查的每個搜尋路徑下方的其他子目錄。

    如果指定 NO_DEFAULT_PATH，則不會將其他路徑新增至搜尋。如果未指定 NO_DEFAULT_PATH，則搜尋程序如下

    1. 搜尋 cmake 特定快取變數中指定的路徑。這些變數旨在透過 -DVAR=value 在命令列上使用。如果傳遞 NO_CMAKE_PATH，則可以略過此步驟。

       <prefix>/lib for each <prefix> in CMAKE_PREFIX_PATH
       CMAKE_LIBRARY_PATH
       CMAKE_FRAMEWORK_PATH

    2. 搜尋 cmake 特定環境變數中指定的路徑。這些變數旨在使用者 shell 設定中設定。如果傳遞 NO_CMAKE_ENVIRONMENT_PATH，則可以略過此步驟。

       <prefix>/lib for each <prefix> in CMAKE_PREFIX_PATH
       CMAKE_LIBRARY_PATH
       CMAKE_FRAMEWORK_PATH

    3. 搜尋 HINTS 選項指定的路徑。這些路徑應該是由系統內省計算的路徑，例如已找到的另一個項目的位置提供的提示。硬式編碼的猜測應該使用 PATHS 選項指定。

    4. 搜尋標準系統環境變數。如果 NO_SYSTEM_ENVIRONMENT_PATH 是一個引數，則可以略過此步驟。

       PATH
       LIB

    5. 搜尋在目前系統的平台檔案中定義的 cmake 變數。如果傳遞 NO_CMAKE_SYSTEM_PATH，則可以略過此步驟。

       <prefix>/lib for each <prefix> in CMAKE_SYSTEM_PREFIX_PATH
       CMAKE_SYSTEM_LIBRARY_PATH
       CMAKE_SYSTEM_FRAMEWORK_PATH

    6. 搜尋 PATHS 選項或命令簡短版本中指定的路徑。這些通常是硬式編碼的猜測。

    在 Darwin 或支援 OS X Frameworks 的系統上，cmake 變數 CMAKE_FIND_FRAMEWORK 可以設定為空白或下列其中之一

       "FIRST"  - Try to find frameworks before standard
                  libraries or headers. This is the default on Darwin.
       "LAST"   - Try to find frameworks after standard
                  libraries or headers.
       "ONLY"   - Only try to find frameworks.
       "NEVER". - Never try to find frameworks.

    在 Darwin 或支援 OS X Application Bundles 的系統上，cmake 變數 CMAKE_FIND_APPBUNDLE 可以設定為空白或下列其中之一

       "FIRST"  - Try to find application bundles before standard
                  programs. This is the default on Darwin.
       "LAST"   - Try to find application bundles after standard
                  programs.
       "ONLY"   - Only try to find application bundles.
       "NEVER". - Never try to find application bundles.

    CMake 變數 CMAKE_FIND_ROOT_PATH 指定一個或多個要附加到所有其他搜尋目錄的目錄。這實際上會將整個搜尋「重新植根」到給定位置下。預設為空。在交叉編譯時，這特別有用，可指向目標環境的根目錄，CMake 也會在該處搜尋。預設情況下，首先會搜尋 CMAKE_FIND_ROOT_PATH 中列出的目錄，然後搜尋未植根的目錄。可以透過設定 CMAKE_FIND_ROOT_PATH_MODE_LIBRARY 來調整預設行為。可以在每次呼叫的基礎上手動覆寫此行為。透過使用 CMAKE_FIND_ROOT_PATH_BOTH，搜尋順序將如上述所述。如果使用 NO_CMAKE_FIND_ROOT_PATH，則不會使用 CMAKE_FIND_ROOT_PATH。如果使用 ONLY_CMAKE_FIND_ROOT_PATH，則只會搜尋重新植根的目錄。

    預設的搜尋順序旨在針對常見的使用案例，從最特定到最不特定。專案可以透過多次呼叫命令並使用 NO_* 選項來覆寫順序

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

    一旦其中一個呼叫成功，就會設定結果變數並儲存在快取中，以便任何呼叫都不會再次搜尋。

    如果找到的程式庫是 framework，則 VAR 將設定為 framework <fullPath>/A.framework 的完整路徑。當 framework 的完整路徑用作程式庫時，CMake 將使用 -framework A 和 -F<fullPath> 將 framework 連結到目標。

  • find_package：載入外部專案的設定。
      find_package(<package> [version] [EXACT] [QUIET]
                   [[REQUIRED|COMPONENTS] [components...]]
                   [NO_POLICY_SCOPE])

    尋找並載入外部專案的設定。會設定 <package>_FOUND，以指示是否找到套件。當找到套件時，會透過套件本身的文件說明變數來提供套件特定資訊。如果找不到套件，QUIET 選項會停用訊息。如果找不到套件，REQUIRED 選項會停止處理並顯示錯誤訊息。在 REQUIRED 選項之後，或在未提供 REQUIRED 選項的情況下，在 COMPONENTS 選項之後，可以列出套件特定的元件清單。[version] 引數會要求找到的套件應與之相容的版本 (格式為 major[.minor[.patch[.tweak]]])。EXACT 選項要求完全比對版本。如果沒有在 find-module 內部的遞迴叫用中指定 [version]，則會自動從外部呼叫轉送 [version] 和 EXACT 引數。目前僅在套件基礎上提供版本支援 (詳細資料如下)。

    使用者程式碼通常應該使用上述簡單簽名來尋找套件。此命令文件的其餘部分會指定完整的命令簽名和搜尋程序的詳細資料。鼓勵希望提供此命令可以找到的套件的專案維護者繼續閱讀。

    此命令有兩種搜尋套件的模式：「模組」模式和「組態」模式。當使用上述簡化簽名呼叫命令時，可以使用「模組」模式。CMake 會在 CMAKE_MODULE_PATH 中，接著在 CMake 安裝目錄中搜尋名為「Find<套件>.cmake」的檔案。如果找到該檔案，CMake 會讀取並處理它。它負責尋找套件、檢查版本，並產生任何需要的訊息。許多尋找模組對版本控制的支援有限或沒有支援；請檢查模組文件。如果找不到模組，命令將繼續執行「組態」模式。

    完整的「組態」模式命令簽名為

      find_package(<package> [version] [EXACT] [QUIET]
                   [[REQUIRED|COMPONENTS] [components...]] [NO_MODULE]
                   [NO_POLICY_SCOPE]
                   [NAMES name1 [name2 ...]]
                   [CONFIGS config1 [config2 ...]]
                   [HINTS path1 [path2 ... ]]
                   [PATHS path1 [path2 ... ]]
                   [PATH_SUFFIXES suffix1 [suffix2 ...]]
                   [NO_DEFAULT_PATH]
                   [NO_CMAKE_ENVIRONMENT_PATH]
                   [NO_CMAKE_PATH]
                   [NO_SYSTEM_ENVIRONMENT_PATH]
                   [NO_CMAKE_BUILDS_PATH]
                   [NO_CMAKE_SYSTEM_PATH]
                   [CMAKE_FIND_ROOT_PATH_BOTH |
                    ONLY_CMAKE_FIND_ROOT_PATH |
                    NO_CMAKE_FIND_ROOT_PATH])

    可以使用 NO_MODULE 選項明確跳過「模組」模式。使用簡化簽名中未指定的選項時，也會隱含此選項。

    「組態」模式會嘗試尋找要尋找的套件提供的組態檔。會建立一個名為 <套件>_DIR 的快取條目，以保存包含該檔案的目錄。預設情況下，該命令會搜尋名為 <套件> 的套件。如果提供 NAMES 選項，則會使用其後面的名稱來取代 <套件>。該命令會為每個指定的名稱搜尋名為「<名稱>Config.cmake」或「<小寫名稱>-config.cmake」的檔案。可以使用 CONFIGS 選項給定一組替換的可能組態檔名稱。搜尋程序如下所述。一旦找到，CMake 會讀取並處理組態檔。由於該檔案由套件提供，它已經知道套件內容的位置。組態檔的完整路徑會儲存在 cmake 變數 <套件>_CONFIG 中。

    如果找不到套件組態檔，CMake 將產生一個描述問題的錯誤，除非指定了 QUIET 參數。如果指定了 REQUIRED 且找不到該套件，則會產生致命錯誤，並且組態步驟會停止執行。如果 <套件>_DIR 已設定為不包含組態檔的目錄，CMake 將忽略它並從頭開始搜尋。

    當提供 [version] 參數時，「組態」模式只會尋找與請求版本聲明相容的套件版本（格式為 major[.minor[.patch[.tweak]]]）。如果提供 EXACT 選項，則只會找到與請求版本聲明完全匹配的套件版本。CMake 沒有建立任何版本號碼含義的慣例。套件版本號碼由套件本身提供的「版本」檔案檢查。對於候選套件組態檔「<config-file>.cmake」，相應的版本檔案位於其旁邊，並命名為「<config-file>-version.cmake」或「<config-file>Version.cmake」。如果沒有此類版本檔案，則假定組態檔與任何請求的版本不相容。找到版本檔案時，會載入它以檢查請求的版本號碼。版本檔案會在巢狀範圍內載入，其中已定義以下變數

      PACKAGE_FIND_NAME          = the <package> name
      PACKAGE_FIND_VERSION       = full requested version string
      PACKAGE_FIND_VERSION_MAJOR = major version if requested, else 0
      PACKAGE_FIND_VERSION_MINOR = minor version if requested, else 0
      PACKAGE_FIND_VERSION_PATCH = patch version if requested, else 0
      PACKAGE_FIND_VERSION_TWEAK = tweak version if requested, else 0
      PACKAGE_FIND_VERSION_COUNT = number of version components, 0 to 4

    版本檔案會檢查它是否滿足請求的版本並設定這些變數

      PACKAGE_VERSION            = full provided version string
      PACKAGE_VERSION_EXACT      = true if version is exact match
      PACKAGE_VERSION_COMPATIBLE = true if version is compatible
      PACKAGE_VERSION_UNSUITABLE = true if unsuitable as any version

    find_package 命令會檢查這些變數，以判斷組態檔是否提供可接受的版本。它們在 find_package 呼叫返回後不可用。如果版本可接受，則會設定以下變數

      <package>_VERSION       = full provided version string
      <package>_VERSION_MAJOR = major version if provided, else 0
      <package>_VERSION_MINOR = minor version if provided, else 0
      <package>_VERSION_PATCH = patch version if provided, else 0
      <package>_VERSION_TWEAK = tweak version if provided, else 0
      <package>_VERSION_COUNT = number of version components, 0 to 4

    並載入相應的套件組態檔。當有多個套件組態檔的版本檔案聲明與請求的版本相容時，未指定選擇哪一個。不會嘗試選擇最高或最接近的版本號碼。

    「組態」模式提供了一個詳細的介面和搜尋程序。大部分介面是為了完整性和供「模組」模式載入的尋找模組在內部使用而提供的。大多數使用者程式碼應該簡單地呼叫

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

    為了找到套件。建議提供 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 Frameworks 和 Application 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)

    在所有情況下，<名稱> 都會被視為不區分大小寫，並對應於任何指定的名稱（<套件> 或 NAMES 給定的名稱）。如果指定了 PATH_SUFFIXES，則會將後綴逐個附加到每個 (W) 或 (U) 目錄條目。

    這組目錄旨在與在其安裝樹中提供組態檔的專案協同工作。上面標記為 (W) 的目錄適用於 Windows 上的安裝，其中前綴可能指向應用程式安裝目錄的頂部。標記為 (U) 的目錄適用於 UNIX 平台上的安裝，其中前綴由多個套件共用。這僅僅是一種慣例，因此在所有平台上仍然會搜尋所有 (W) 和 (U) 目錄。標記為 (A) 的目錄適用於 Apple 平台上的安裝。cmake 變數 CMAKE_FIND_FRAMEWORK 和 CMAKE_FIND_APPBUNDLE 決定了如下所述的偏好順序。

    安裝前綴的集合是使用以下步驟構建的。如果指定了 NO_DEFAULT_PATH，則會啟用所有 NO_* 選項。

    1. 搜尋 cmake 特定快取變數中指定的路徑。這些變數旨在透過 -DVAR=value 在命令列上使用。如果傳遞 NO_CMAKE_PATH，則可以略過此步驟。

       CMAKE_PREFIX_PATH
       CMAKE_FRAMEWORK_PATH
       CMAKE_APPBUNDLE_PATH

    2. 搜尋 cmake 特定環境變數中指定的路徑。這些變數旨在使用者 shell 設定中設定。如果傳遞 NO_CMAKE_ENVIRONMENT_PATH，則可以略過此步驟。

       CMAKE_PREFIX_PATH
       CMAKE_FRAMEWORK_PATH
       CMAKE_APPBUNDLE_PATH

    3. 搜尋 HINTS 選項指定的路徑。這些應該是由系統內省計算的路徑，例如已找到的另一項目的位置提供的提示。硬編碼的猜測應該使用 PATHS 選項指定。

    4. 搜尋標準系統環境變數。如果傳遞了 NO_SYSTEM_ENVIRONMENT_PATH，則可以跳過此步驟。以「/bin」或「/sbin」結尾的路徑條目會自動轉換為其父目錄。

       PATH

    5. 搜尋最近在 CMake GUI 中組態的專案建置樹。如果傳遞了 NO_CMAKE_BUILDS_PATH，則可以跳過此步驟。它適用於使用者依序建置多個相依專案的情況。

    6. 搜尋在目前系統的平台檔案中定義的 cmake 變數。如果傳遞了 NO_CMAKE_SYSTEM_PATH，則可以跳過此步驟。

       CMAKE_SYSTEM_PREFIX_PATH
       CMAKE_SYSTEM_FRAMEWORK_PATH
       CMAKE_SYSTEM_APPBUNDLE_PATH

    7. 搜尋 PATHS 選項指定的路徑。這些通常是硬編碼的猜測。

    在 Darwin 或支援 OS X Frameworks 的系統上，cmake 變數 CMAKE_FIND_FRAMEWORK 可以設定為空白或下列其中之一

       "FIRST"  - Try to find frameworks before standard
                  libraries or headers. This is the default on Darwin.
       "LAST"   - Try to find frameworks after standard
                  libraries or headers.
       "ONLY"   - Only try to find frameworks.
       "NEVER". - Never try to find frameworks.

    在 Darwin 或支援 OS X Application Bundles 的系統上，cmake 變數 CMAKE_FIND_APPBUNDLE 可以設定為空白或下列其中之一

       "FIRST"  - Try to find application bundles before standard
                  programs. This is the default on Darwin.
       "LAST"   - Try to find application bundles after standard
                  programs.
       "ONLY"   - Only try to find application bundles.
       "NEVER". - Never try to find application bundles.

    CMake 變數 CMAKE_FIND_ROOT_PATH 指定一個或多個目錄，這些目錄會附加到所有其他搜尋目錄之前。這有效地將整個搜尋「重新紮根」到給定的位置下。預設情況下，它為空。當交叉編譯指向目標環境的根目錄時，它特別有用，CMake 也會在該處搜尋。預設情況下，首先會搜尋 CMAKE_FIND_ROOT_PATH 中列出的目錄，然後會搜尋未紮根的目錄。可以使用設定 CMAKE_FIND_ROOT_PATH_MODE_PACKAGE 來調整預設行為。此行為可以在每次呼叫時手動覆寫。透過使用 CMAKE_FIND_ROOT_PATH_BOTH，搜尋順序將如上所述。如果使用 NO_CMAKE_FIND_ROOT_PATH，則不會使用 CMAKE_FIND_ROOT_PATH。如果使用 ONLY_CMAKE_FIND_ROOT_PATH，則只會搜尋重新紮根的目錄。

    預設的搜尋順序旨在針對常見的使用案例，從最特定到最不特定。專案可以透過多次呼叫命令並使用 NO_* 選項來覆寫順序

       find_package(<package> PATHS paths... NO_DEFAULT_PATH)
       find_package(<package>)

    一旦其中一個呼叫成功，就會設定結果變數並儲存在快取中，以便任何呼叫都不會再次搜尋。

    請參閱 cmake_policy() 命令文件以了解 NO_POLICY_SCOPE 選項的討論。

  • find_path：尋找包含檔案的目錄。
       find_path(<VAR> name1 [path1 path2 ...])

    這是命令的簡短簽名，在許多情況下都足夠使用。它與 find_path(<VAR> name1 [PATHS path1 path2 ...]) 相同

       find_path(
                 <VAR>
                 name | NAMES name1 [name2 ...]
                 [HINTS path1 [path2 ... ENV var]]
                 [PATHS path1 [path2 ... ENV var]]
                 [PATH_SUFFIXES suffix1 [suffix2 ...]]
                 [DOC "cache documentation string"]
                 [NO_DEFAULT_PATH]
                 [NO_CMAKE_ENVIRONMENT_PATH]
                 [NO_CMAKE_PATH]
                 [NO_SYSTEM_ENVIRONMENT_PATH]
                 [NO_CMAKE_SYSTEM_PATH]
                 [CMAKE_FIND_ROOT_PATH_BOTH |
                  ONLY_CMAKE_FIND_ROOT_PATH |
                  NO_CMAKE_FIND_ROOT_PATH]
                )

    此命令用於尋找包含指定檔案的目錄。會建立一個名為 <VAR> 的快取條目，以儲存此命令的結果。如果在目錄中找到檔案，則結果會儲存在變數中，並且除非清除該變數，否則不會重複搜尋。如果找不到任何項目，則結果會是 <VAR>-NOTFOUND，並且下次使用相同變數呼叫 find_path 時將再次嘗試搜尋。要搜尋的目錄中的檔案名稱由 NAMES 參數後列出的名稱指定。其他搜尋位置可以在 PATHS 參數之後指定。如果在 HINTS 或 PATHS 區段中找到 ENV var，則會讀取環境變數 var，並將其從系統環境變數轉換為 cmake 樣式的路徑清單。例如，ENV PATH 將是一種列出系統路徑變數的方法。DOC 後面的參數將用於快取中的文件字串。PATH_SUFFIXES 指定要檢查的每個搜尋路徑下的其他子目錄。

    如果指定 NO_DEFAULT_PATH，則不會將其他路徑新增至搜尋。如果未指定 NO_DEFAULT_PATH，則搜尋程序如下

    1. 搜尋 cmake 特定快取變數中指定的路徑。這些變數旨在透過 -DVAR=value 在命令列上使用。如果傳遞 NO_CMAKE_PATH，則可以略過此步驟。

       <prefix>/include for each <prefix> in CMAKE_PREFIX_PATH
       CMAKE_INCLUDE_PATH
       CMAKE_FRAMEWORK_PATH

    2. 搜尋 cmake 特定環境變數中指定的路徑。這些變數旨在使用者 shell 設定中設定。如果傳遞 NO_CMAKE_ENVIRONMENT_PATH，則可以略過此步驟。

       <prefix>/include for each <prefix> in CMAKE_PREFIX_PATH
       CMAKE_INCLUDE_PATH
       CMAKE_FRAMEWORK_PATH

    3. 搜尋 HINTS 選項指定的路徑。這些路徑應該是由系統內省計算的路徑，例如已找到的另一個項目的位置提供的提示。硬式編碼的猜測應該使用 PATHS 選項指定。

    4. 搜尋標準系統環境變數。如果 NO_SYSTEM_ENVIRONMENT_PATH 是一個引數，則可以略過此步驟。

       PATH
       INCLUDE

    5. 搜尋在目前系統的平台檔案中定義的 cmake 變數。如果傳遞 NO_CMAKE_SYSTEM_PATH，則可以略過此步驟。

       <prefix>/include for each <prefix> in CMAKE_SYSTEM_PREFIX_PATH
       CMAKE_SYSTEM_INCLUDE_PATH
       CMAKE_SYSTEM_FRAMEWORK_PATH

    6. 搜尋 PATHS 選項或命令簡短版本中指定的路徑。這些通常是硬式編碼的猜測。

    在 Darwin 或支援 OS X Frameworks 的系統上，cmake 變數 CMAKE_FIND_FRAMEWORK 可以設定為空白或下列其中之一

       "FIRST"  - Try to find frameworks before standard
                  libraries or headers. This is the default on Darwin.
       "LAST"   - Try to find frameworks after standard
                  libraries or headers.
       "ONLY"   - Only try to find frameworks.
       "NEVER". - Never try to find frameworks.

    在 Darwin 或支援 OS X Application Bundles 的系統上，cmake 變數 CMAKE_FIND_APPBUNDLE 可以設定為空白或下列其中之一

       "FIRST"  - Try to find application bundles before standard
                  programs. This is the default on Darwin.
       "LAST"   - Try to find application bundles after standard
                  programs.
       "ONLY"   - Only try to find application bundles.
       "NEVER". - Never try to find 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，則只會搜尋重新植根的目錄。

    預設的搜尋順序旨在針對常見的使用案例，從最特定到最不特定。專案可以透過多次呼叫命令並使用 NO_* 選項來覆寫順序

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

    一旦其中一個呼叫成功，就會設定結果變數並儲存在快取中，以便任何呼叫都不會再次搜尋。

    搜尋框架時，如果檔案指定為 A/b.h，則框架搜尋將尋找 A.framework/Headers/b.h。如果找到，則路徑將設定為框架的路徑。CMake 會將此轉換為正確的 -F 選項以包含該檔案。

  • find_program：尋找可執行程式。
       find_program(<VAR> name1 [path1 path2 ...])

    這是命令的簡寫簽名，在許多情況下都足夠。它與 find_program(<VAR> name1 [PATHS path1 path2 ...]) 相同

       find_program(
                 <VAR>
                 name | NAMES name1 [name2 ...]
                 [HINTS path1 [path2 ... ENV var]]
                 [PATHS path1 [path2 ... ENV var]]
                 [PATH_SUFFIXES suffix1 [suffix2 ...]]
                 [DOC "cache documentation string"]
                 [NO_DEFAULT_PATH]
                 [NO_CMAKE_ENVIRONMENT_PATH]
                 [NO_CMAKE_PATH]
                 [NO_SYSTEM_ENVIRONMENT_PATH]
                 [NO_CMAKE_SYSTEM_PATH]
                 [CMAKE_FIND_ROOT_PATH_BOTH |
                  ONLY_CMAKE_FIND_ROOT_PATH |
                  NO_CMAKE_FIND_ROOT_PATH]
                )

    此命令用於尋找程式。會建立一個名為 <VAR> 的快取條目，以儲存此命令的結果。如果找到程式，則結果會儲存在變數中，並且除非清除該變數，否則不會重複搜尋。如果找不到任何項目，則結果會是 <VAR>-NOTFOUND，並且下次使用相同變數呼叫 find_program 時將再次嘗試搜尋。要搜尋的程式名稱由 NAMES 參數後列出的名稱指定。其他搜尋位置可以在 PATHS 參數之後指定。如果在 HINTS 或 PATHS 區段中找到 ENV var，則會讀取環境變數 var，並將其從系統環境變數轉換為 cmake 樣式的路徑清單。例如，ENV PATH 將是一種列出系統路徑變數的方法。DOC 後面的參數將用於快取中的文件字串。PATH_SUFFIXES 指定要檢查的每個搜尋路徑下的其他子目錄。

    如果指定 NO_DEFAULT_PATH，則不會將其他路徑新增至搜尋。如果未指定 NO_DEFAULT_PATH，則搜尋程序如下

    1. 搜尋 cmake 特定快取變數中指定的路徑。這些變數旨在透過 -DVAR=value 在命令列上使用。如果傳遞 NO_CMAKE_PATH，則可以略過此步驟。

       <prefix>/[s]bin for each <prefix> in CMAKE_PREFIX_PATH
       CMAKE_PROGRAM_PATH
       CMAKE_APPBUNDLE_PATH

    2. 搜尋 cmake 特定環境變數中指定的路徑。這些變數旨在使用者 shell 設定中設定。如果傳遞 NO_CMAKE_ENVIRONMENT_PATH，則可以略過此步驟。

       <prefix>/[s]bin for each <prefix> in CMAKE_PREFIX_PATH
       CMAKE_PROGRAM_PATH
       CMAKE_APPBUNDLE_PATH

    3. 搜尋 HINTS 選項指定的路徑。這些路徑應該是由系統內省計算的路徑，例如已找到的另一個項目的位置提供的提示。硬式編碼的猜測應該使用 PATHS 選項指定。

    4. 搜尋標準系統環境變數。如果 NO_SYSTEM_ENVIRONMENT_PATH 是一個引數，則可以略過此步驟。

       PATH

    5. 搜尋在目前系統的平台檔案中定義的 cmake 變數。如果傳遞 NO_CMAKE_SYSTEM_PATH，則可以略過此步驟。

       <prefix>/[s]bin for each <prefix> in CMAKE_SYSTEM_PREFIX_PATH
       CMAKE_SYSTEM_PROGRAM_PATH
       CMAKE_SYSTEM_APPBUNDLE_PATH

    6. 搜尋 PATHS 選項或命令簡短版本中指定的路徑。這些通常是硬式編碼的猜測。

    在 Darwin 或支援 OS X Frameworks 的系統上，cmake 變數 CMAKE_FIND_FRAMEWORK 可以設定為空白或下列其中之一

       "FIRST"  - Try to find frameworks before standard
                  libraries or headers. This is the default on Darwin.
       "LAST"   - Try to find frameworks after standard
                  libraries or headers.
       "ONLY"   - Only try to find frameworks.
       "NEVER". - Never try to find frameworks.

    在 Darwin 或支援 OS X Application Bundles 的系統上，cmake 變數 CMAKE_FIND_APPBUNDLE 可以設定為空白或下列其中之一

       "FIRST"  - Try to find application bundles before standard
                  programs. This is the default on Darwin.
       "LAST"   - Try to find application bundles after standard
                  programs.
       "ONLY"   - Only try to find application bundles.
       "NEVER". - Never try to find application bundles.

    CMake 變數 CMAKE_FIND_ROOT_PATH 指定一個或多個目錄，這些目錄會被附加到所有其他搜尋目錄的前面。這有效地「重新根目錄化」在給定位置下的整個搜尋。預設為空。當進行交叉編譯時，這特別有用，它可以指向目標環境的根目錄，而 CMake 也會在那裡進行搜尋。預設情況下，會先搜尋 CMAKE_FIND_ROOT_PATH 中列出的目錄，然後才會搜尋非根目錄。預設行為可以透過設定 CMAKE_FIND_ROOT_PATH_MODE_PROGRAM 來調整。此行為可以在每次呼叫時手動覆寫。使用 CMAKE_FIND_ROOT_PATH_BOTH 時，搜尋順序將如上述所述。如果使用 NO_CMAKE_FIND_ROOT_PATH，則不會使用 CMAKE_FIND_ROOT_PATH。如果使用 ONLY_CMAKE_FIND_ROOT_PATH，則只會搜尋重新根目錄化的目錄。

    預設的搜尋順序旨在針對常見的使用案例，從最特定到最不特定。專案可以透過多次呼叫命令並使用 NO_* 選項來覆寫順序

       find_program(<VAR> NAMES name PATHS paths... NO_DEFAULT_PATH)
       find_program(<VAR> NAMES name)

    一旦其中一個呼叫成功，就會設定結果變數並儲存在快取中，以便任何呼叫都不會再次搜尋。

  • fltk_wrap_ui：建立 FLTK 使用者介面包裝函式。
      fltk_wrap_ui(resultingLibraryName source1
                   source2 ... sourceN )

    為所有列出的 .fl 和 .fld 檔案產生 .h 和 .cxx 檔案。產生的 .h 和 .cxx 檔案會被新增到名為 resultingLibraryName_FLTK_UI_SRCS 的變數中，此變數應新增到您的程式庫中。

  • foreach：針對清單中的每個值評估一組命令。
      foreach(loop_var arg1 arg2 ...)
        COMMAND1(ARGS ...)
        COMMAND2(ARGS ...)
        ...
      endforeach(loop_var)
      foreach(loop_var RANGE total)
      foreach(loop_var RANGE start stop [step])

    foreach 和對應的 endforeach 之間的所有命令都會被記錄下來，而不會被呼叫。一旦評估了 endforeach，就會針對原始 foreach 命令中列出的每個引數呼叫記錄的命令清單一次。在迴圈的每次迭代之前，「${loop_var}」將被設定為一個變數，其中包含清單中的目前值。

    Foreach 也可以迭代產生的數字範圍。此迭代有三種型別

    * 當指定單個數字時，範圍將包含從 0 到「總數」的元素。

    * 當指定兩個數字時，範圍將包含從第一個數字到第二個數字的元素。

    * 第三個可選數字是從第一個數字迭代到第二個數字時使用的增量。

  • function：開始記錄一個函式，以供稍後作為命令呼叫。
      function(<name> [arg1 [arg2 [arg3 ...]]])
        COMMAND1(ARGS ...)
        COMMAND2(ARGS ...)
        ...
      endfunction(<name>)

    定義一個名為 <name> 的函式，該函式會接收名為 arg1 arg2 arg3 (...) 的引數。在 function 之後，但在對應的 endfunction 之前的列出命令，在函式被呼叫之前不會被呼叫。當函式被呼叫時，函式中記錄的命令首先會被修改，將形式參數 (${arg1}) 替換為傳遞的引數，然後再作為正常命令呼叫。除了參考形式參數之外，您還可以參考變數 ARGC，該變數會被設定為傳遞到函式中的引數數量，以及 ARGV0 ARGV1 ARGV2 ...，這些變數會包含傳遞引數的實際值。這有助於建立具有可選引數的函式。此外，ARGV 會保存傳遞給函式的所有引數清單，而 ARGN 則會保存傳遞到最後一個預期引數的引數清單。

    請參閱 cmake_policy() 命令文件，以了解函式內原則的行為。

  • get_cmake_property：取得 CMake 執行個體的屬性。
      get_cmake_property(VAR property)

    從 CMake 執行個體取得屬性。屬性的值會儲存在變數 VAR 中。如果找不到屬性，CMake 會回報錯誤。一些支援的屬性包括：VARIABLES、CACHE_VARIABLES、COMMANDS、MACROS 和 COMPONENTS。

  • get_directory_property：取得目錄的屬性。
      get_directory_property(VAR [DIRECTORY dir] property)

    從目錄取得屬性。屬性的值會儲存在變數 VAR 中。如果找不到屬性，CMake 會回報錯誤。這些屬性包括：VARIABLES、CACHE_VARIABLES、COMMANDS、MACROS、INCLUDE_DIRECTORIES、LINK_DIRECTORIES、DEFINITIONS、INCLUDE_REGULAR_EXPRESSION、LISTFILE_STACK、PARENT_DIRECTORY 和 DEFINITION varname。如果提供了 DIRECTORY 引數，則會擷取所提供目錄的屬性，而不是目前目錄的屬性。您只能在 cmake 遍歷目錄期間或之後取得目錄的屬性。

  • get_filename_component：取得完整檔案名稱的特定元件。
      get_filename_component(VarName FileName
                             PATH|ABSOLUTE|NAME|EXT|NAME_WE
                             [CACHE])

    將 VarName 設定為 FileName 的路徑 (PATH)、檔案名稱 (NAME)、副檔名 (EXT)、不含副檔名的檔案名稱 (NAME_WE) 或不含符號連結的完整絕對檔案名稱 (ABSOLUTE)。請注意，路徑會轉換為 Unix 斜線格式，且不包含尾端斜線。始終會考慮最長的副檔名。如果指定了可選的 CACHE 引數，則結果變數會新增到快取中。

      get_filename_component(VarName FileName
                             PROGRAM [PROGRAM_ARGS ArgVar]
                             [CACHE])

    FileName 中的程式將在系統搜尋路徑中找到，或保留為完整路徑。如果 PROGRAM_ARGS 與 PROGRAM 一起出現，則 FileName 字串中存在的任何命令列引數都會從程式名稱中分割出來，並儲存在 ArgVar 中。這用於在命令列字串中將程式名稱與其引數分開。

  • get_property：取得屬性。
      get_property(<variable>
                   <GLOBAL             |
                    DIRECTORY [dir]    |
                    TARGET    <target> |
                    SOURCE    <source> |
                    TEST      <test>   |
                    VARIABLE>
                   PROPERTY <name>
                   [SET | DEFINED | BRIEF_DOCS | FULL_DOCS])

    從範圍中的一個物件取得一個屬性。第一個引數指定儲存結果的變數。第二個引數決定要從哪個範圍取得屬性。它必須是以下其中之一

    GLOBAL 範圍是唯一的，且不接受名稱。

    DIRECTORY 範圍預設為目前目錄，但可以使用完整或相對路徑命名另一個目錄（已由 CMake 處理）。

    TARGET 範圍必須命名一個現有的目標。

    SOURCE 範圍必須命名一個原始程式檔。

    TEST 範圍必須命名一個現有的測試。

    VARIABLE 範圍是唯一的，且不接受名稱。

    必要的 PROPERTY 選項後面緊跟著要取得的屬性名稱。如果未設定屬性，則會傳回空值。如果給定 SET 選項，則會將變數設定為一個布林值，指示是否已設定屬性。如果給定 DEFINED 選項，則會將變數設定為一個布林值，指示是否已定義屬性，例如使用 define_property。如果給定 BRIEF_DOCS 或 FULL_DOCS，則會將變數設定為一個字串，其中包含所要求屬性的文件。如果要求未定義的屬性的文件，則會傳回 NOTFOUND。

  • get_source_file_property：取得原始程式檔的屬性。
      get_source_file_property(VAR file property)

    從原始程式檔取得屬性。屬性的值會儲存在變數 VAR 中。如果找不到屬性，則 VAR 將被設定為「NOTFOUND」。使用 set_source_files_properties 設定屬性值。原始程式檔屬性通常控制檔案的建置方式。始終存在的一個屬性是 LOCATION

  • get_target_property：從目標取得屬性。
      get_target_property(VAR target property)

    從目標取得屬性。屬性的值會儲存在變數 VAR 中。如果找不到屬性，則 VAR 將被設定為「NOTFOUND」。使用 set_target_properties 設定屬性值。屬性通常用於控制目標的建置方式，但有些會改為查詢目標。此命令可以取得到目前為止建立的任何目標的屬性。目標不需要位於目前的 CMakeLists.txt 檔案中。

  • get_test_property：取得測試的屬性。
      get_test_property(test VAR property)

    從測試取得屬性。屬性的值會儲存在變數 VAR 中。如果找不到屬性，CMake 會回報錯誤。如需標準屬性的清單，您可以輸入 cmake --help-property-list

  • if：有條件地執行一組命令。
      if(expression)
        # then section.
        COMMAND1(ARGS ...)
        COMMAND2(ARGS ...)
        ...
      elseif(expression2)
        # elseif section.
        COMMAND1(ARGS ...)
        COMMAND2(ARGS ...)
        ...
      else(expression)
        # else section.
        COMMAND1(ARGS ...)
        COMMAND2(ARGS ...)
        ...
      endif(expression)

    評估給定的運算式。如果結果為 true，則會呼叫 THEN 區段中的命令。否則，會呼叫 else 區段中的命令。elseif 和 else 區段是可選的。您可以有多個 elseif 子句。請注意，相同的運算式必須提供給 if 和 endif。可以使用長運算式，而順序或優先順序是先評估 EXISTS、COMMAND 和 DEFINED 運算子。然後會評估任何 EQUAL、LESS、GREATER、STRLESS、STRGREATER、STREQUAL、MATCHES。然後會評估 NOT 運算子，最後會評估 AND、OR 運算子。可能的運算式有

      if(variable)

    如果變數的值不是空的、0、N、NO、OFF、FALSE、NOTFOUND 或 <variable>-NOTFOUND，則為 True。

      if(NOT variable)

    如果變數的值是空的、0、N、NO、OFF、FALSE、NOTFOUND 或 <variable>-NOTFOUND，則為 True。

      if(variable1 AND variable2)

    如果兩個變數都被單獨視為 true，則為 True。

      if(variable1 OR variable2)

    如果任一個變數被單獨視為 true，則為 True。

      if(COMMAND command-name)

    如果給定的名稱是可以呼叫的命令、巨集或函式，則為 True。

      if(POLICY policy-id)

    如果給定的名稱是現有的原則（形式為 CMP<NNNN>），則為 True。

      if(TARGET target-name)

    如果給定的名稱是現有的目標（已建置或已匯入），則為 True。

      if(EXISTS file-name)
      if(EXISTS directory-name)

    如果指定的檔案或目錄存在，則為 True。只有針對完整路徑，行為才是明確定義的。

      if(file1 IS_NEWER_THAN file2)

    如果 file1 比 file2 新，或者如果其中一個檔案不存在，則為 True。只有針對完整路徑，行為才是明確定義的。

      if(IS_DIRECTORY directory-name)

    如果給定的名稱是目錄，則為 True。只有針對完整路徑，行為才是明確定義的。

      if(IS_ABSOLUTE path)

    如果給定的路徑是絕對路徑，則為 True。

       if(variable MATCHES regex)
      if(string MATCHES regex)

    如果給定的字串或變數的值符合給定的規則運算式，則為 True。

      if(variable LESS number)
      if(string LESS number)
      if(variable GREATER number)
      if(string GREATER number)
      if(variable EQUAL number)
      if(string EQUAL number)

    如果給定的字串或變數的值是有效的數字，且不等式或等式為 true，則為 True。

      if(variable STRLESS string)
      if(string STRLESS string)
      if(variable STRGREATER string)
      if(string STRGREATER string)
      if(variable STREQUAL string)
      if(string STREQUAL string)

    如果給定的字串或變數的值在詞彙上小於（或大於或等於）右側的字串，則為 True。

      if(version1 VERSION_LESS version2)
      if(version1 VERSION_EQUAL version2)
      if(version1 VERSION_GREATER version2)

    元件式的整數版本號碼比較（版本格式為 major[.minor[.patch[.tweak]]]）。

      if(DEFINED variable)

    如果已定義給定的變數，則為 True。變數為 true 或 false 並不重要，重要的是是否已設定變數。

  • include：從給定的檔案讀取 CMake 清單檔案程式碼。
      include(<file|module> [OPTIONAL] [RESULT_VARIABLE <VAR>]
                            [NO_POLICY_SCOPE])

    從給定的檔案讀取 CMake 清單檔案程式碼。檔案中的命令會立即處理，就像它們被寫入 include 命令的位置一樣。如果存在 OPTIONAL，則如果檔案不存在，則不會引發錯誤。如果給定 RESULT_VARIABLE，則變數會設定為已包含的完整檔案名稱，如果失敗，則會設定為 NOTFOUND。

    如果指定模組而不是檔案，則會在 CMAKE_MODULE_PATH 中搜尋名稱為 <modulename>.cmake 的檔案。

    請參閱 cmake_policy() 命令文件以了解 NO_POLICY_SCOPE 選項的討論。

  • include_directories：將 include 目錄新增到組建中。
      include_directories([AFTER|BEFORE] [SYSTEM] dir1 dir2 ...)

    將給定的目錄新增到編譯器搜尋 include 檔案的目錄中。預設情況下，目錄會附加到目前的目錄清單中。可以透過將 CMAKE_include_directories_BEFORE 設定為 ON 來變更此預設行為。透過使用 BEFORE 或 AFTER，您可以選擇在附加和前置之間進行選擇，而獨立於預設值。如果給定 SYSTEM 選項，則會告知編譯器，這些目錄在某些平台上是用作系統 include 目錄。

  • include_external_msproject：在工作區中包含外部 Microsoft 專案檔案。
      include_external_msproject(projectname location
                                 dep1 dep2 ...)

    在產生的工作區檔案中包含外部 Microsoft 專案。目前在 UNIX 上沒有任何作用。這會建立一個名為 INCLUDE_EXTERNAL_MSPROJECT_[projectname] 的目標。這可以用於 add_dependencies 命令中，以使專案依賴於外部專案。

  • include_regular_expression：設定用於相依性檢查的規則運算式。
      include_regular_expression(regex_match [regex_complain])

    設定相依性檢查中使用的規則運算式。只有符合 regex_match 的檔案會被追蹤為相依性。只有符合 regex_complain 的檔案，如果找不到它們，才會產生警告（不會搜尋標準標頭路徑）。預設值為

      regex_match    = "^.*$" (match everything)
      regex_complain = "^$" (match empty string only)
  • install：指定在安裝時執行的規則。

    此命令會為專案產生安裝規則。在原始程式目錄中呼叫此命令所指定的規則會在安裝期間依序執行。跨目錄的順序未定義。

    此命令有多個簽名。其中一些會為檔案和目標定義安裝屬性。此處會涵蓋多個簽名共用的屬性，但這些屬性僅對指定它們的簽名有效。

    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(TARGETS targets... [EXPORT <export-name>]
              [[ARCHIVE|LIBRARY|RUNTIME|FRAMEWORK|BUNDLE|
                PRIVATE_HEADER|PUBLIC_HEADER|RESOURCE]
               [DESTINATION <dir>]
               [PERMISSIONS permissions...]
               [CONFIGURATIONS [Debug|Release|...]]
               [COMPONENT <component>]
               [OPTIONAL] [NAMELINK_ONLY|NAMELINK_SKIP]
              ] [...])

    TARGETS 形式指定從專案安裝目標的規則。可以安裝五種目標檔案類型：ARCHIVE、LIBRARY、RUNTIME、FRAMEWORK 和 BUNDLE。可執行檔會被視為 RUNTIME 目標，但標記有 MACOSX_BUNDLE 屬性的可執行檔在 OS X 上會被視為 BUNDLE 目標。靜態程式庫一律會被視為 ARCHIVE 目標。模組程式庫一律會被視為 LIBRARY 目標。對於非 DLL 平台，共享程式庫會被視為 LIBRARY 目標，但標記有 FRAMEWORK 屬性的共享程式庫在 OS X 上會被視為 FRAMEWORK 目標。對於 DLL 平台，共享程式庫的 DLL 部分會被視為 RUNTIME 目標，而對應的導入程式庫會被視為 ARCHIVE 目標。包括 Cygwin 在內的所有基於 Windows 的系統都是 DLL 平台。ARCHIVE、LIBRARY、RUNTIME 和 FRAMEWORK 參數會變更後續屬性套用的目標類型。如果沒有指定任何參數，則安裝屬性會套用於所有目標類型。如果只指定了一個參數，則只會安裝該類型的目標（可用於僅安裝 DLL 或僅安裝導入程式庫）。

    PRIVATE_HEADER、PUBLIC_HEADER 和 RESOURCE 參數會導致後續屬性套用於在非 Apple 平台上安裝 FRAMEWORK 共享程式庫目標的相關檔案。在 Apple 平台上會忽略這些參數定義的規則，因為相關檔案會安裝到框架資料夾內的適當位置。詳細資訊請參閱 PRIVATE_HEADER、PUBLIC_HEADER 和 RESOURCE 目標屬性的文件。

    可以將 NAMELINK_ONLY 或 NAMELINK_SKIP 指定為 LIBRARY 選項。在某些平台上，帶有版本的共享程式庫具有符號連結，例如

      lib<name>.so -> lib<name>.so.1

    其中「lib<name>.so.1」是程式庫的 soname，而「lib<name>.so」是一個「namelink」，允許連結器在給定「-l<name>」時找到該程式庫。NAMELINK_ONLY 選項會導致在安裝程式庫目標時僅安裝 namelink。NAMELINK_SKIP 選項會導致在安裝程式庫目標時安裝 namelink 之外的程式庫檔案。當未給定任何選項時，兩個部分都會安裝。在帶版本的共享程式庫沒有 namelink 或程式庫沒有版本化的平台上，NAMELINK_SKIP 選項會安裝程式庫，而 NAMELINK_ONLY 選項不會安裝任何內容。有關建立帶版本的共享程式庫的詳細資訊，請參閱 VERSION 和 SOVERSION 目標屬性。

    可以在對此命令的 TARGETS 形式的單次呼叫中指定一組或多組屬性。可以將目標多次安裝到不同的位置。考慮假設的目標「myExe」、「mySharedLib」和「myStaticLib」。程式碼

        install(TARGETS myExe mySharedLib myStaticLib
                RUNTIME DESTINATION bin
                LIBRARY DESTINATION lib
                ARCHIVE DESTINATION lib/static)
        install(TARGETS mySharedLib DESTINATION /some/full/path)

    會將 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。在非 DLL 平台上，mySharedLib 會被安裝到 <prefix>/lib 和 /some/full/path。

    EXPORT 選項會將已安裝的目標檔案與名為 <export-name> 的匯出相關聯。它必須出現在任何 RUNTIME、LIBRARY 或 ARCHIVE 選項之前。有關詳細資訊，請參閱下方 install(EXPORT ...) 簽名的文件。

    安裝 EXCLUDE_FROM_ALL 設定為 true 的目標具有未定義的行為。

    FILES 簽名

      install(FILES files... DESTINATION <dir>
              [PERMISSIONS permissions...]
              [CONFIGURATIONS [Debug|Release|...]]
              [COMPONENT <component>]
              [RENAME <name>] [OPTIONAL])

    FILES 形式指定專案安裝檔案的規則。以相對路徑給定的檔案名稱會相對於目前的原始碼目錄進行解譯。如果沒有給定 PERMISSIONS 參數，此形式安裝的檔案預設會具有 OWNER_WRITE、OWNER_READ、GROUP_READ 和 WORLD_READ 權限。

    PROGRAMS 簽名

      install(PROGRAMS files... DESTINATION <dir>
              [PERMISSIONS permissions...]
              [CONFIGURATIONS [Debug|Release|...]]
              [COMPONENT <component>]
              [RENAME <name>] [OPTIONAL])

    PROGRAMS 形式與 FILES 形式相同，不同之處在於已安裝檔案的預設權限還包括 OWNER_EXECUTE、GROUP_EXECUTE 和 WORLD_EXECUTE。此形式旨在安裝非目標的程式，例如 shell 腳本。使用 TARGETS 形式來安裝在專案內建置的目標。

    DIRECTORY 簽名

      install(DIRECTORY dirs... DESTINATION <dir>
              [FILE_PERMISSIONS permissions...]
              [DIRECTORY_PERMISSIONS permissions...]
              [USE_SOURCE_PERMISSIONS]
              [CONFIGURATIONS [Debug|Release|...]]
              [COMPONENT <component>] [FILES_MATCHING]
              [[PATTERN <pattern> | REGEX <regex>]
               [EXCLUDE] [PERMISSIONS permissions...]] [...])

    DIRECTORY 形式將一個或多個目錄的內容安裝到指定的目的地。目錄結構會逐字複製到目的地。每個目錄名稱的最後一個元件會附加到目的地目錄，但是可以使用尾隨斜線來避免這種情況，因為它會使最後一個元件為空。以相對路徑給定的目錄名稱會相對於目前的原始碼目錄進行解譯。如果沒有給定任何輸入目錄名稱，則會建立目的地目錄，但不會在其中安裝任何內容。FILE_PERMISSIONS 和 DIRECTORY_PERMISSIONS 選項指定給定目的地中檔案和目錄的權限。如果指定了 USE_SOURCE_PERMISSIONS 且沒有指定 FILE_PERMISSIONS，則會從原始目錄結構複製檔案權限。如果沒有指定任何權限，則檔案將會被賦予命令的 FILES 形式中指定的預設權限，而目錄將會被賦予命令的 PROGRAMS 形式中指定的預設權限。

    可以使用 PATTERN 或 REGEX 選項以精細的粒度控制目錄的安裝。這些「匹配」選項指定一個 globbing 模式或正規表示式，以匹配在輸入目錄中遇到的目錄或檔案。它們可以用於將某些選項（請參閱下方）套用於遇到的檔案和目錄的子集。會將每個輸入檔案或目錄的完整路徑（帶有正斜線）與運算式進行匹配。PATTERN 只會匹配完整的檔案名稱：完整路徑中匹配模式的部分必須出現在檔案名稱的末尾，並且前面有斜線。REGEX 會匹配完整路徑的任何部分，但可以使用 '/' 和 '$' 來模擬 PATTERN 行為。預設情況下，無論是否匹配，都會安裝所有檔案和目錄。可以在第一個匹配選項之前給定 FILES_MATCHING 選項，以停用未被任何運算式匹配的檔案（但不包括目錄）的安裝。例如，程式碼

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

    會從原始碼樹擷取並安裝標頭檔。

    某些選項可以跟在 PATTERN 或 REGEX 運算式後面，並且僅套用於與其匹配的檔案或目錄。EXCLUDE 選項將會跳過匹配的檔案或目錄。PERMISSIONS 選項會覆寫匹配檔案或目錄的權限設定。例如，程式碼

      install(DIRECTORY icons scripts/ DESTINATION share/myproj
              PATTERN "CVS" EXCLUDE
              PATTERN "scripts/*"
              PERMISSIONS OWNER_EXECUTE OWNER_WRITE OWNER_READ
                          GROUP_EXECUTE GROUP_READ)

    會將 icons 目錄安裝到 share/myproj/icons，並將 scripts 目錄安裝到 share/myproj。圖示將會獲得預設檔案權限，指令碼將會被賦予特定的權限，並且將會排除任何 CVS 目錄。

    SCRIPT 和 CODE 簽名

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

    SCRIPT 形式將會在安裝期間呼叫給定的 CMake 腳本檔案。如果腳本檔案名稱是相對路徑，則會相對於目前的原始碼目錄進行解譯。CODE 形式將會在安裝期間呼叫給定的 CMake 程式碼。程式碼會被指定為雙引號字串中的單個參數。例如，程式碼

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

    將會在安裝期間列印訊息。

    EXPORT 簽名

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

    EXPORT 形式會產生並安裝一個 CMake 檔案，其中包含將目標從安裝樹匯入另一個專案的程式碼。目標安裝會使用上面記載的 install(TARGETS ...) 簽名的 EXPORT 選項與匯出 <export-name> 相關聯。NAMESPACE 選項會將 <namespace> 添加到寫入匯入檔案的目標名稱的前面。預設情況下，產生的檔案會被命名為 <export-name>.cmake，但是可以使用 FILE 選項來指定不同的名稱。給定 FILE 選項的值必須是具有「.cmake」副檔名的檔案名稱。如果給定了 CONFIGURATIONS 選項，則只有在安裝其中一個指定的組態時才會安裝該檔案。此外，產生的匯入檔案將只會參考匹配的目標組態。如果指定的 COMPONENT 選項與給定 <export-name> 相關聯的目標的選項不符，則行為未定義。如果匯出中包含程式庫目標，但是與其連結的目標未包含，則行為未指定。

    EXPORT 形式對於協助外部專案使用目前專案建置和安裝的目標很有用。例如，程式碼

      install(TARGETS myexe EXPORT myproj DESTINATION bin)
      install(EXPORT myproj NAMESPACE mp_ DESTINATION lib/myproj)

    會將可執行檔 myexe 安裝到 <prefix>/bin，並將匯入它的程式碼安裝到檔案「<prefix>/lib/myproj/myproj.cmake」。外部專案可以使用 include 命令載入此檔案，並使用匯入的目標名稱 mp_myexe 參考安裝樹中的 myexe 可執行檔，就好像目標是在其自己的樹中建置的一樣。

    注意：此命令會取代 INSTALL_TARGETS 命令和目標屬性 PRE_INSTALL_SCRIPT 和 POST_INSTALL_SCRIPT。它也會取代 INSTALL_FILES 和 INSTALL_PROGRAMS 命令的 FILES 形式。這些安裝規則相對於 INSTALL_TARGETS、INSTALL_FILES 和 INSTALL_PROGRAMS 命令產生的規則的處理順序未定義。

  • link_directories：指定連結器將在其中尋找程式庫的目錄。
      link_directories(directory1 directory2 ...)

    指定連結器應在其中搜尋程式庫的路徑。該命令將僅適用於在其呼叫之後建立的目標。由於歷史原因，給定此命令的相對路徑會未經變更地傳遞給連結器（這與許多將相對路徑解譯為相對於目前原始碼目錄的 CMake 命令不同）。

  • list：清單操作。
      list(LENGTH <list> <output variable>)
      list(GET <list> <element index> [<element index> ...] <output variable>)
      list(APPEND <list> <element> [<element> ...])
      list(FIND <list> <value> <output variable>)
      list(INSERT <list> <element_index> <element> [<element> ...])
      list(REMOVE_ITEM <list> <value> [<value> ...])
      list(REMOVE_AT <list> <index> [<index> ...])
      list(REMOVE_DUPLICATES <list>)
      list(REVERSE <list>)
      list(SORT <list>)

    LENGTH 會傳回給定清單的長度。

    GET 會從清單中傳回由索引指定的元素清單。

    APPEND 會將元素附加到清單。

    FIND 會傳回清單中指定元素的索引，如果找不到則傳回 -1。

    INSERT 會將元素插入到清單的指定位置。

    REMOVE_AT 和 REMOVE_ITEM 會從清單中移除項目。不同之處在於 REMOVE_ITEM 會移除給定的項目，而 REMOVE_AT 會移除給定索引處的項目。

    REMOVE_DUPLICATES 會移除清單中的重複項目。

    REVERSE 會原地反轉列表的內容。

    SORT 會原地依字母順序排序列表。

    注意：在 CMake 中，列表是以分號 (;) 分隔的字串群組。可以使用 set 命令建立列表。例如，`set(var a b c d e)` 會建立一個包含 a;b;c;d;e 的列表，而 `set(var "a b c d e")` 會建立一個字串或一個包含單個項目的列表。

    當指定索引值時，如果 <元素索引> 為 0 或更大，則從列表的開頭開始索引，其中 0 代表第一個列表元素。如果 <元素索引> 為 -1 或更小，則從列表的末尾開始索引，其中 -1 代表最後一個列表元素。使用負索引計數時要小心：它們不是從 0 開始的。-0 等同於 0，即第一個列表元素。

  • load_cache：從另一個專案的 CMake 快取載入數值。
      load_cache(pathToCacheFile READ_WITH_PREFIX
                 prefix entry1...)

    讀取快取，並將請求的項目儲存在變數中，變數名稱會加上指定的前綴。這只會讀取數值，不會在本地專案的快取中建立項目。

      load_cache(pathToCacheFile [EXCLUDE entry1...]
                 [INCLUDE_INTERNALS entry1...])

    從另一個快取載入數值，並將它們以內部項目的形式儲存在本地專案的快取中。這對於依賴於在不同目錄樹中建置的另一個專案的專案很有用。可以使用 EXCLUDE 選項來提供要排除的項目列表。可以使用 INCLUDE_INTERNALS 來提供要包含的內部項目列表。通常，不會引入任何內部項目。強烈不建議使用此形式的命令，但它是為了向後相容性而提供的。

  • load_command：將命令載入到正在執行的 CMake 中。
      load_command(COMMAND_NAME <loc1> [loc2 ...])

    會在給定的位置搜尋名稱為 cmCOMMAND_NAME 的程式庫。如果找到，它會被載入為模組，並且該命令會被添加到可用的 CMake 命令集中。通常，會在執行此命令之前使用 TRY_COMPILE 來編譯模組。如果命令成功載入，則會將一個名為

      CMAKE_LOADED_COMMAND_<COMMAND_NAME>

    的變數設定為已載入模組的完整路徑。否則，不會設定該變數。

  • macro：開始錄製巨集，以便稍後以命令的形式調用。
      macro(<name> [arg1 [arg2 [arg3 ...]]])
        COMMAND1(ARGS ...)
        COMMAND2(ARGS ...)
        ...
      endmacro(<name>)

    定義一個名為 <name> 的巨集，它接受名為 arg1 arg2 arg3 (...) 的參數。在 macro 之後但在相符的 endmacro 之前列出的命令，在巨集被調用之前不會被調用。當巨集被調用時，巨集中記錄的命令會先被修改，將形式參數 (${arg1}) 替換為傳遞的參數，然後像普通命令一樣被調用。除了引用形式參數外，您還可以引用數值 ${ARGC}，它會被設定為傳遞到函式的參數數量，以及 ${ARGV0} ${ARGV1} ${ARGV2} ...，它們將具有傳遞參數的實際值。這有助於建立具有可選參數的巨集。此外，${ARGV} 保存傳遞給巨集的所有參數的列表，而 ${ARGN} 保存傳遞的超出最後預期參數的參數列表。請注意，巨集的參數和 ARGN 等數值並不是通常意義上的 CMake 變數。它們是字串替換，很像 C 前處理器對巨集所做的操作。如果您想要真正的 CMake 變數，您應該查看 function 命令。

    請參閱 cmake_policy() 命令文件，了解巨集中策略的行為。

  • mark_as_advanced：將 CMake 快取變數標記為進階。
      mark_as_advanced([CLEAR|FORCE] VAR VAR2 VAR...)

    將指定的快取變數標記為進階。除非啟用了顯示進階選項，否則進階變數不會顯示在任何 CMake GUI 中。如果第一個參數是 CLEAR，則進階變數會變回非進階。如果第一個參數是 FORCE，則該變數會被設為進階。如果未指定 FORCE 或 CLEAR，則新數值會被標記為進階，但如果變數已經具有進階/非進階狀態，則不會更改。

    在腳本模式下，此命令不會執行任何操作。

  • math：數學運算式。
      math(EXPR <output variable> <math expression>)

    EXPR 會評估數學運算式，並將結果傳回輸出變數。數學運算式的範例是 '5 * ( 10 + 13 )'。支援的運算子有 + - * / % | & ^ ~ << >> * / %。它們的含義與在 C 程式碼中的含義相同。

  • message：向使用者顯示訊息。
      message([SEND_ERROR | STATUS | FATAL_ERROR]
              "message to display" ...)

    預設情況下，訊息會顯示在彈出視窗 (CMakeSetup) 中，或顯示在 cmake 的 stdout 中，或顯示在 ccmake 的錯誤區段中。如果第一個參數是 SEND_ERROR，則會引發錯誤，並跳過產生階段。如果第一個參數是 FATAL_ERROR，則會停止所有處理。如果第一個參數是 STATUS，則訊息會顯示在 GUI 的進度列中，或在命令列 cmake 中以 -- 顯示。

  • option：提供使用者可以選擇開啟或關閉的選項。
      option(<option_variable> "help string describing option"
             [initial value])

    提供一個選項，供使用者選擇為 ON 或 OFF。如果未提供初始值，則使用 OFF。

  • output_required_files：輸出指定原始檔所需的原始檔列表。
      output_required_files(srcfile outputfile)

    輸出指定 srcfile 所需的所有原始檔列表。此列表會寫入 outputfile。這類似於寫出 srcfile 的相依性，但它會盡可能從 .h 檔案跳到 .cxx、.c 和 .cpp 檔案。

  • project：設定整個專案的名稱。
      project(projectname [CXX] [C] [Java])

    設定專案的名稱。這會建立變數 projectname_BINARY_DIR 和 projectname_SOURCE_DIR。您可以選擇指定專案支援的語言。預設情況下，支援所有語言。如果您沒有 C++ 編譯器，但想要使用 cmake 建置 C 程式，則請使用此選項。

  • qt_wrap_cpp：建立 Qt 包裝函式。
      qt_wrap_cpp(resultingLibraryName DestName
                  SourceLists ...)

    為 SourceLists 中列出的所有 .h 檔案產生 moc 檔案。moc 檔案會使用 DestName 原始碼清單添加到程式庫中。

  • qt_wrap_ui：建立 Qt 使用者介面包裝函式。
      qt_wrap_ui(resultingLibraryName HeadersDestName
                 SourcesDestName SourceLists ...)

    為 SourceLists 中列出的所有 .ui 檔案產生 .h 和 .cxx 檔案。.h 檔案會使用 HeadersDestNamesource 清單添加到程式庫中。.cxx 檔案會使用 SourcesDestNamesource 清單添加到程式庫中。

  • remove_definitions：移除 add_definitions 新增的 -D 定義標誌。
      remove_definitions(-DFOO -DBAR ...)

    從目前目錄及以下目錄中來源的編譯器命令列中移除標誌（由 add_definitions 新增）。

  • return：從檔案、目錄或函式傳回。
      return()

    從檔案、目錄或函式傳回。當在包含的檔案中（透過 include() 或 find_package()）遇到此命令時，會導致目前檔案的處理停止，並將控制權傳回給包含檔案。如果在未由其他檔案包含的檔案中遇到此命令，例如 CMakeLists.txt，則如果有父目錄，則會將控制權傳回給父目錄。如果在函式中呼叫 return，則會將控制權傳回給函式的呼叫者。請注意，巨集不是函式，並且不會像函式一樣處理 return。

  • separate_arguments：將以空格分隔的參數分割為以分號分隔的列表。
      separate_arguments(VARIABLE)

    將 VARIABLE 的值轉換為以分號分隔的列表。所有空格都會被替換為 ';'。這有助於產生命令列。

  • set：將 CMAKE 變數設定為給定值。
      set(<variable> <value> [[CACHE <type> <docstring> [FORCE]] | PARENT_SCOPE])

    在 CMake 內，將 <variable> 設定為值 <value>。在將 <variable> 設定為 <value> 之前，會先展開 <value>。如果存在 CACHE，則會將 <variable> 放入快取中。然後需要 <type> 和 <docstring>。CMake GUI 使用 <type> 來選擇使用者設定數值的 Widget。<type> 的數值可以是下列其中之一

      FILEPATH = File chooser dialog.
      PATH     = Directory chooser dialog.
      STRING   = Arbitrary string.
      BOOL     = Boolean ON/OFF checkbox.
      INTERNAL = No GUI entry (used for persistent variables).

    如果 <type> 是 INTERNAL，則 <value> 會始終寫入快取中，取代快取中存在的任何數值。如果它不是快取變數，則始終會寫入目前的 makefile 中。FORCE 選項會覆寫快取值，移除使用者所做的任何變更。

    如果存在 PARENT_SCOPE，則會在目前範圍之上的範圍中設定變數。每個新目錄或函式都會建立一個新範圍。此命令會將變數的值設定到父目錄或呼叫函式中（以適用於當前案例者為準）。如果未指定 VALUE，則會從父範圍中移除該變數。

      set(<variable> <value1> ... <valueN>)

    在此情況下，<variable> 會被設定為以分號分隔的值列表。

    <variable> 可以是環境變數，例如

      set( ENV{PATH} /home/martink )

    在這種情況下，會設定環境變數。

  • set_directory_properties：設定目錄的屬性。
      set_directory_properties(PROPERTIES prop1 value1 prop2 value2)

    設定目前目錄和子目錄的屬性。如果找不到該屬性，CMake 會報告錯誤。屬性包括：INCLUDE_DIRECTORIES、LINK_DIRECTORIES、INCLUDE_REGULAR_EXPRESSION 和 ADDITIONAL_MAKE_CLEAN_FILES。

    ADDITIONAL_MAKE_CLEAN_FILES 是檔案的列表，這些檔案將在「make clean」階段中被清除。

  • set_property：在給定的範圍中設定指定的屬性。
      set_property(<GLOBAL                            |
                    DIRECTORY [dir]                   |
                    TARGET    [target1 [target2 ...]] |
                    SOURCE    [src1 [src2 ...]]       |
                    TEST      [test1 [test2 ...]]>
                   [APPEND]
                   PROPERTY <name> [value1 [value2 ...]])

    在零個或多個範圍的物件上設定一個屬性。第一個參數會決定設定屬性的範圍。它必須是下列其中之一

    GLOBAL 範圍是唯一的，且不接受名稱。

    DIRECTORY 範圍預設為目前目錄，但可以使用完整或相對路徑命名另一個目錄（已由 CMake 處理）。

    TARGET 範圍可以命名零個或多個現有目標。

    SOURCE 範圍可以命名零個或多個原始檔。

    TEST 範圍可以命名零個或多個現有測試。

    必要的 PROPERTY 選項後面會立即跟著要設定的屬性名稱。剩餘的參數會用於以分號分隔的列表形式組成屬性值。如果給定 APPEND 選項，則該列表會附加到任何現有的屬性值。

  • set_source_files_properties：原始檔可以具有影響其建置方式的屬性。
      set_source_files_properties(file1 file2 ...
                                  PROPERTIES prop1 value1
                                  prop2 value2 ...)

    在檔案上設定屬性。該命令的語法是列出所有要變更的檔案，然後提供您要設定的數值。您也可以自行建立屬性。以下屬性由 CMake 使用。ABSTRACT 旗標 (布林值) 由某些類別包裝命令使用。如果 WRAP_EXCLUDE (布林值) 為 true，則許多包裝命令會忽略此檔案。如果 GENERATED (布林值) 為 true，則當此原始檔被添加到目標時，如果此原始檔不存在，則不會發生錯誤。顯然，在建置目標之前，必須建立它（大概是透過自訂命令）。如果 HEADER_FILE_ONLY (布林值) 屬性為 true，則不會編譯該檔案。如果您想將額外的非建置檔案添加到 IDE 中，這很有用。OBJECT_DEPENDS (字串) 會將相依性添加到物件檔案中。COMPILE_FLAGS (字串) 會在編譯原始檔時作為額外的命令列引數傳遞給編譯器。LANGUAGE (字串) CXX|C 會變更用於編譯原始檔的預設編譯器。在 PROJECT 命令中需要啟用使用的語言。如果將 SYMBOLIC (布林值) 設定為 true，則會通知建置系統該原始檔實際上不是在磁碟上建立的，而是用作建置規則的符號名稱。

  • set_target_properties：目標可以具有影響其建置方式的屬性。
      set_target_properties(target1 target2 ...
                            PROPERTIES prop1 value1
                            prop2 value2 ...)

    在目標上設定屬性。該命令的語法是列出所有要變更的檔案，然後提供您要設定的數值。您可以使用任何您想要的 prop-value 配對，稍後可以使用 GET_TARGET_PROPERTY 命令擷取它。

    影響目標輸出檔名稱的屬性如下。PREFIX 和 SUFFIX 屬性會覆蓋預設的目標名稱前綴（例如「lib」）和後綴（例如「.so」）。IMPORT_PREFIX 和 IMPORT_SUFFIX 是 DLL 對應的匯入程式庫的等效屬性（適用於 SHARED 程式庫目標）。OUTPUT_NAME 設定目標在建置時的實際名稱，並且可用於協助建立兩個名稱相同的目標，即使 CMake 需要唯一的邏輯目標名稱。還有一個 <CONFIG>_OUTPUT_NAME 可以根據每個組態設定輸出名稱。<CONFIG>_POSTFIX 會為在 <CONFIG> 所命名的組態下建置的目標實際名稱設定後綴（以大寫表示，例如「DEBUG_POSTFIX」）。此屬性的值會在建立目標時初始化為變數 CMAKE_<CONFIG>_POSTFIX 的值（可執行目標除外，因為較早的 CMake 版本不對可執行檔使用此變數）。

    LINK_FLAGS 屬性可用於將額外的旗標新增至目標的連結步驟。LINK_FLAGS_<CONFIG> 將會新增至組態 <CONFIG>，例如 DEBUG、RELEASE、MINSIZEREL、RELWITHDEBINFO。DEFINE_SYMBOL 設定在共用程式庫中編譯來源時定義的預處理器符號名稱。如果未在此處設定，則預設會設定為 target_EXPORTS（如果目標不是有效的 C 識別碼，則會進行一些取代）。這對於標頭來說很有用，可以知道它們是從程式庫內部還是外部包含，以便正確設定 dllexport/dllimport 修飾詞。COMPILE_FLAGS 屬性設定用於建置目標內來源的其他編譯器旗標。它也可用於傳遞額外的預處理器定義。

    LINKER_LANGUAGE 屬性用於變更用於連結可執行檔或共用程式庫的工具。預設設定語言以符合程式庫中的檔案。CXX 和 C 是此屬性的常見值。

    對於共用程式庫，可以使用 VERSION 和 SOVERSION 分別指定建置版本和 API 版本。當建置或安裝時，如果平台支援符號連結且連結器支援 so-names，則會建立適當的符號連結。如果僅指定其中一個，則會假設遺失的版本號碼相同。對於可執行檔，可以使用 VERSION 指定建置版本。當建置或安裝時，如果平台支援符號連結，則會建立適當的符號連結。對於 Windows 上的共用程式庫和可執行檔，會剖析 VERSION 屬性以擷取「major.minor」版本號碼。這些數字用作二進位的影像版本。

    有一些屬性用於指定 RPATH 規則。INSTALL_RPATH 是以分號分隔的清單，指定在已安裝的目標中使用的 rpath（適用於支援它的平台）。INSTALL_RPATH_USE_LINK_PATH 是一個布林值，如果設定為 true，則會將連結器搜尋路徑中和專案外部的目錄附加到 INSTALL_RPATH。SKIP_BUILD_RPATH 是一個布林值，指定是否跳過 rpath 的自動產生，允許目標從建置樹執行。BUILD_WITH_INSTALL_RPATH 是一個布林值，指定是否使用 INSTALL_RPATH 在建置樹中連結目標。這優先於 SKIP_BUILD_RPATH，並避免在安裝之前重新連結的需求。INSTALL_NAME_DIR 是一個字串，指定 Mac OSX 上共用程式庫的「install_name」欄位的目錄部分，以便在已安裝的目標中使用。建立目標時，會使用變數 CMAKE_INSTALL_RPATH、CMAKE_INSTALL_RPATH_USE_LINK_PATH、CMAKE_SKIP_BUILD_RPATH、CMAKE_BUILD_WITH_INSTALL_RPATH 和 CMAKE_INSTALL_NAME_DIR 的值來初始化這些屬性。

    PROJECT_LABEL 可用於變更 IDE（如 Visual Studio）中目標的名稱。VS_KEYWORD 可以設定為變更 Visual Studio 關鍵字，例如，如果設定為 Qt4VSv1.0，則 QT 整合的效果會更好。

    可以設定 VS_SCC_PROJECTNAME、VS_SCC_LOCALPATH、VS_SCC_PROVIDER 以在 Visual Studio 專案檔中新增原始碼控制繫結的支援。

    當建置程式庫時，CMake 預設會產生程式碼，以移除所有可能名稱的任何現有程式庫。這是支援使用者選項在 STATIC 和 SHARED 之間切換的程式庫所需要的。但是，當使用 OUTPUT_NAME 使用不同的邏輯目標名稱建置名稱相同的靜態和共用程式庫時，這兩個目標將會移除彼此的檔案。可以透過將 CLEAN_DIRECT_OUTPUT 屬性設定為 1 來防止這種情況發生。

    PRE_INSTALL_SCRIPT 和 POST_INSTALL_SCRIPT 屬性是指定要在安裝目標之前和之後執行的 CMake 指令碼的舊方法。它們僅在使用舊的 INSTALL_TARGETS 命令來安裝目標時使用。請改用 INSTALL 命令。

    EXCLUDE_FROM_DEFAULT_BUILD 屬性由 Visual Studio 產生器使用。如果設定為 1，則當您選取「建置方案」時，目標不會成為預設建置的一部分。

  • set_tests_properties：設定測試的屬性。
      set_tests_properties(test1 [test2...] PROPERTIES prop1 value1 prop2 value2)

    設定測試的屬性。如果找不到屬性，CMake 將會報告錯誤。這些屬性包括：

    WILL_FAIL：如果設定為 true，這會反轉測試的通過/失敗旗標。

    PASS_REGULAR_EXPRESSION：如果設定，則會根據指定的規則運算式檢查測試輸出，且至少必須符合一個規則運算式，否則測試將會失敗。

      Example: PASS_REGULAR_EXPRESSION "TestPassed;All ok"

    FAIL_REGULAR_EXPRESSION：如果設定，如果輸出符合其中一個指定的規則運算式，則測試將會失敗。

      Example: PASS_REGULAR_EXPRESSION "[^a-z]Error;ERROR;Failed"

    PASS_REGULAR_EXPRESSION 和 FAIL_REGULAR_EXPRESSION 都需要規則運算式清單。

  • site_name：將給定的變數設定為電腦名稱。
      site_name(variable)
  • source_group：在 makefile 中定義來源的分組。
      source_group(name [REGULAR_EXPRESSION regex] [FILES src1 src2 ...])

    定義來源將會放置在專案檔中的群組。這主要用於在 Visual Studio 中設定檔案索引標籤。名稱已列出或符合規則運算式的任何檔案都會放置在此群組中。如果檔案符合多個群組，則會優先選擇最後一個明確列出該檔案的群組（如果有的話）。如果沒有群組明確列出該檔案，則會優先選擇最後一個規則運算式符合該檔案的群組。

    群組的名稱可以包含反斜線以指定子群組

      source_group(outer\\inner ...)

    為了向後相容，此命令也支援以下格式

      source_group(name regex)
  • string：字串運算。
      string(REGEX MATCH <regular_expression>
             <output variable> <input> [<input>...])
      string(REGEX MATCHALL <regular_expression>
             <output variable> <input> [<input>...])
      string(REGEX REPLACE <regular_expression>
             <replace_expression> <output variable>
             <input> [<input>...])
      string(REPLACE <match_string>
             <replace_string> <output variable>
             <input> [<input>...])
      string(COMPARE EQUAL <string1> <string2> <output variable>)
      string(COMPARE NOTEQUAL <string1> <string2> <output variable>)
      string(COMPARE LESS <string1> <string2> <output variable>)
      string(COMPARE GREATER <string1> <string2> <output variable>)
      string(ASCII <number> [<number> ...] <output variable>)
      string(CONFIGURE <string1> <output variable>
             [@ONLY] [ESCAPE_QUOTES])
      string(TOUPPER <string1> <output variable>)
      string(TOLOWER <string1> <output variable>)
      string(LENGTH <string> <output variable>)
      string(SUBSTRING <string> <begin> <length> <output variable>)
      string(STRIP <string> <output variable>)
      string(RANDOM [LENGTH <length>] [ALPHABET <alphabet>]
             <output variable>)

    REGEX MATCH 將會比對規則運算式一次，並將比對結果儲存在輸出變數中。

    REGEX MATCHALL 將會盡可能多次比對規則運算式，並將比對結果以清單形式儲存在輸出變數中。

    REGEX REPLACE 將會盡可能多次比對規則運算式，並在輸出中將比對取代為取代運算式。取代運算式可以使用 \1、\2、...、\9 參照比對的括號分隔的子運算式。請注意，在 CMake 程式碼中需要兩個反斜線 (\\1) 才能透過引數剖析取得反斜線。

    REPLACE 將會將輸入中所有出現的 match_string 取代為 replace_string，並將結果儲存在輸出中。

    COMPARE EQUAL/NOTEQUAL/LESS/GREATER 將會比較字串，並在輸出變數中儲存 true 或 false。

    ASCII 將會將所有數字轉換為對應的 ASCII 字元。

    CONFIGURE 將會轉換字串，就像 CONFIGURE_FILE 轉換檔案一樣。

    TOUPPER/TOLOWER 將會將字串轉換為大寫/小寫字元。

    LENGTH 將會傳回給定字串的長度。

    SUBSTRING 將會傳回給定字串的子字串。

    STRIP 將會傳回已移除開頭和結尾空格的給定字串子字串。

    RANDOM 將會傳回由給定字母表中的字元組成的給定長度的隨機字串。預設長度為 5 個字元，預設字母表為所有數字和大寫和小寫字母。

    下列字元在規則運算式中具有特殊意義

       ^         Matches at beginning of a line
       $         Matches at end of a line
       .         Matches any single character
       [ ]       Matches any character(s) inside the brackets
       [^ ]      Matches any character(s) not inside the brackets
        -        Matches any character in range on either side of a dash
       *         Matches preceding pattern zero or more times
       +         Matches preceding pattern one or more times
       ?         Matches preceding pattern zero or once only
       |         Matches a pattern on either side of the |
       ()        Saves a matched subexpression, which can be referenced in the REGEX REPLACE operation. Additionally it is saved in the special CMake variables CMAKE_MATCH_(0..9).
  • target_link_libraries：將目標連結至給定的程式庫。
      target_link_libraries(<target> [lib1 [lib2 [...]]]
                            [[debug|optimized|general] <lib>] ...)

    指定要連結到指定目標的程式庫清單。如果任何程式庫名稱符合目前專案中目標的名稱，則會在建置系統中自動新增相依性，以確保在連結目標之前，要連結的程式庫是最新的。

    「debug」、「optimized」或「general」關鍵字表示緊接在其後的程式庫僅用於對應的建置組態。「debug」關鍵字對應於 Debug 組態（或如果設定了 DEBUG_CONFIGURATIONS 全域屬性，則對應於其中命名的組態）。「optimized」關鍵字對應於所有其他組態。「general」關鍵字對應於所有組態，並且是完全可選的（如果省略則會假設）。可以透過建立和連結到 IMPORTED 程式庫目標，來實現更細微的每個組態規則。請參閱 add_library 命令的 IMPORTED 模式以取得更多資訊。

    程式庫相依性預設是可傳遞的。當此目標連結到另一個目標時，連結到此目標的程式庫也會出現在另一個目標的連結行上。請參閱 LINK_INTERFACE_LIBRARIES 目標屬性以覆蓋目標的可傳遞連結相依性集。

      target_link_libraries(<target> LINK_INTERFACE_LIBRARIES
                            [[debug|optimized|general] <lib>] ...)

    LINK_INTERFACE_LIBRARIES 模式會將程式庫附加到 LINK_INTERFACE_LIBRARIES 及其每個組態的對應目標屬性，而不是使用它們進行連結。指定為「debug」的程式庫會附加到 LINK_INTERFACE_LIBRARIES_DEBUG 屬性（或附加到如果設定了 DEBUG_CONFIGURATIONS 全域屬性，則對應於其中列出的組態的屬性）。指定為「optimized」的程式庫會附加到 LINK_INTERFACE_LIBRARIES 屬性。指定為「general」（或沒有任何關鍵字）的程式庫會被視為同時指定為「debug」和「optimized」。

  • try_compile：嘗試編譯一些程式碼。
      try_compile(RESULT_VAR bindir srcdir
                  projectName <targetname> [CMAKE_FLAGS <Flags>]
                  [OUTPUT_VARIABLE var])

    嘗試編譯程式。在此形式中，srcdir 應包含具有 CMakeLists.txt 檔案和所有來源的完整 CMake 專案。在此命令執行後，bindir 和 srcdir 不會被刪除。如果指定了 <target name>，則只會建置該目標，否則會建置 all 或 ALL_BUILD 目標。

      try_compile(RESULT_VAR bindir srcfile
                  [CMAKE_FLAGS <Flags>]
                  [COMPILE_DEFINITIONS <flags> ...]
                  [OUTPUT_VARIABLE var]
                  [COPY_FILE <filename> )

    嘗試編譯 srcfile。在這種情況下，使用者只需要提供原始檔。CMake 將會建立適當的 CMakeLists.txt 檔案來建置來源。如果使用 COPY_FILE，則會將已編譯的檔案複製到給定的檔案。

    在這個版本中，`bindir/CMakeFiles/CMakeTmp` 中的所有檔案都會被自動清除，為了進行除錯，可以將 `--debug-trycompile` 傳遞給 cmake，以避免清除。一些額外的標誌可以包括 `INCLUDE_DIRECTORIES`、`LINK_DIRECTORIES` 和 `LINK_LIBRARIES`。`COMPILE_DEFINITIONS` 是 `-Ddefinition`，將會被傳遞到編譯行。`try_compile` 會即時建立一個 `CMakeList.txt` 檔案，看起來像這樣

      add_definitions( <expanded COMPILE_DEFINITIONS from calling cmake>)
      include_directories(${INCLUDE_DIRECTORIES})
      link_directories(${LINK_DIRECTORIES})
      add_executable(cmTryCompileExec sources)
      target_link_libraries(cmTryCompileExec ${LINK_LIBRARIES})

    在這兩個版本的命令中，如果指定了 `OUTPUT_VARIABLE`，則建置過程的輸出將儲存在給定的變數中。將成功或失敗的回傳值儲存在 `RESULT_VAR` 中。`CMAKE_FLAGS` 可以用來將 `-DVAR:TYPE=VALUE` 標誌傳遞給在建置期間執行的 cmake。

  • try_run: 嘗試編譯然後執行一些程式碼。
      try_run(RUN_RESULT_VAR COMPILE_RESULT_VAR
              bindir srcfile [CMAKE_FLAGS <Flags>]
              [COMPILE_DEFINITIONS <flags>]
              [COMPILE_OUTPUT_VARIABLE comp]
              [RUN_OUTPUT_VARIABLE run]
              [OUTPUT_VARIABLE var]
              [ARGS <arg1> <arg2>...])

    嘗試編譯一個原始碼檔案。在 `COMPILE_RESULT_VAR` 中回傳 `TRUE` 或 `FALSE` 表示成功或失敗。然後，如果編譯成功，執行該可執行檔並在 `RUN_RESULT_VAR` 中回傳其退出碼。如果可執行檔已建置，但執行失敗，則 `RUN_RESULT_VAR` 將被設定為 `FAILED_TO_RUN`。`COMPILE_OUTPUT_VARIABLE` 指定編譯步驟的輸出將儲存到的變數。`RUN_OUTPUT_VARIABLE` 指定執行可執行檔的輸出將儲存到的變數。

    為了相容性原因，仍然支援 `OUTPUT_VARIABLE`，它會提供編譯和執行步驟的合併輸出。


    交叉編譯問題

    當進行交叉編譯時，第一步中編譯的可執行檔通常無法在建置主機上執行。`try_run()` 會檢查 `CMAKE_CROSSCOMPILING` 變數，以偵測 CMake 是否處於交叉編譯模式。如果是這種情況，它仍然會嘗試編譯可執行檔，但不會嘗試執行可執行檔。相反，它會建立快取變數，這些變數必須由使用者填入，或透過在某些 CMake 腳本檔案中預先設定，使其成為可執行檔如果在其目標平台上執行會產生的值。這些變數是 `RUN_RESULT_VAR`（說明見上文），如果使用了 `RUN_OUTPUT_VARIABLE`（或 `OUTPUT_VARIABLE`），則會產生一個額外的快取變數 `RUN_RESULT_VAR__COMPILE_RESULT_VAR__TRYRUN_OUTPUT`。這旨在保存可執行檔的標準輸出和標準錯誤。

    為了使您的專案更容易進行交叉編譯，請僅在真正需要時使用 `try_run`。如果您使用 `try_run`，請僅在真正需要時使用 `RUN_OUTPUT_VARIABLE`（或 `OUTPUT_VARIABLE`）。使用它們時，當進行交叉編譯時，快取變數必須手動設定為可執行檔的輸出。您也可以使用 `if(CMAKE_CROSSCOMPILING)`「保護」對 `try_run` 的呼叫，並為這種情況提供一個易於預先設定的替代方案。

  • unset: 取消設定變數、快取變數或環境變數。
      unset(<variable> [CACHE])

    移除指定的變數，使其變成未定義。如果存在 `CACHE`，則變數會從快取中移除，而不是從目前的範圍中移除。

    <variable> 可以是環境變數，例如

      unset(ENV{LD_LIBRARY_PATH})

    在這種情況下，變數將從目前的環境中移除。

  • variable_watch: 監視 CMake 變數的變更。
      variable_watch(<variable name> [<command to execute>])

    如果指定的變數發生變更，將會印出關於變數已變更的訊息。如果指定了命令，則會執行該命令。該命令將會收到以下引數：`COMMAND(<變數> <存取> <值> <目前清單檔案> <堆疊>)`

  • while: 當條件為 true 時，評估一組命令
      while(condition)
        COMMAND1(ARGS ...)
        COMMAND2(ARGS ...)
        ...
      endwhile(condition)

    在 `while` 和相符的 `endwhile` 之間的所有命令都會被記錄下來，而不會被調用。一旦評估了 `endwhile`，只要條件為 true，就會調用記錄的命令列表。該條件使用與 `if` 命令相同的邏輯進行評估。

屬性

  CMake Properties - Properties supported by CMake, the Cross-Platform Makefile Generator.

這是 CMake 所支援屬性的文件。屬性可以有不同的範圍。它們可以被指派給來源檔案、目錄、目標或全域指派給 CMake。透過修改屬性的值，可以自訂建置系統的行為。

全域範圍的屬性

  • ALLOW_DUPLICATE_CUSTOM_TARGETS: 允許建立重複的自訂目標。

    通常，CMake 要求專案中建置的所有目標都具有全域唯一的邏輯名稱（請參閱原則 CMP0002）。這是在 Xcode 和 VS IDE 產生器中產生有意義的專案檔案名稱所必需的。它也允許明確地引用目標名稱。

    Makefile 產生器能夠支援重複的自訂目標名稱。對於僅關心 Makefile 產生器且不希望支援 Xcode 或 VS IDE 產生器的專案，可以將此屬性設定為 true，以允許重複的自訂目標。此屬性允許在不同目錄中的多個 `add_custom_target` 命令呼叫指定相同的目標名稱。但是，設定此屬性將會導致非 Makefile 產生器產生錯誤並拒絕產生專案。

  • DEBUG_CONFIGURATIONS: 指定哪些組態用於除錯。

    該值必須是以分號分隔的組態名稱列表。目前，此屬性僅由 `target_link_libraries` 命令使用（詳細資訊請參閱其文件）。未來可能會定義其他用途。

    此屬性必須在專案的最上層設定，並在第一個 `target_link_libraries` 命令調用之前設定。如果列表中的任何條目與專案的有效組態不符，則行為未定義。

  • DISABLED_FEATURES: 在 CMake 執行期間停用的功能列表。

    在 CMake 執行期間停用的功能列表。預設情況下，它包含所有未找到的套件的名稱。這是使用 `<NAME>_FOUND` 變數確定的。被搜尋的 `QUIET` 套件不會列出。專案可以將自己的功能新增至此列表。此屬性由 FeatureSummary.cmake 中的巨集使用。

  • ENABLED_FEATURES: 在 CMake 執行期間啟用的功能列表。

    在 CMake 執行期間啟用的功能列表。預設情況下，它包含所有找到的套件的名稱。這是使用 `<NAME>_FOUND` 變數確定的。被搜尋的 `QUIET` 套件不會列出。專案可以將自己的功能新增至此列表。此屬性由 FeatureSummary.cmake 中的巨集使用。

  • ENABLED_LANGUAGES: 包含目前啟用的語言列表的唯讀屬性

    設定為目前啟用的語言列表。

  • FIND_LIBRARY_USE_LIB64_PATHS: `FIND_LIBRARY` 是否應自動搜尋 `lib64` 目錄。

    `FIND_LIBRARY_USE_LIB64_PATHS` 是一個布林值，指定在建置 64 位元二進位檔時，`FIND_LIBRARY` 命令是否應自動搜尋搜尋路徑中名為 `lib` 的目錄的 `lib64` 變體。

  • GLOBAL_DEPENDS_DEBUG_MODE: 啟用全域目標相依性圖形除錯模式。

    CMake 會在原生建置系統產生開始時自動分析全域目標間相依性圖形。此屬性會使其在標準錯誤中顯示其分析的詳細資訊。

  • IN_TRY_COMPILE: 在 `try-compile` 組態期間為 true 的唯讀屬性。

    在 `TRY_COMPILE` 或 `TRY_RUN` 命令內建置專案時為 True。

  • PACKAGES_FOUND: 在 CMake 執行期間找到的套件列表。

    在 CMake 執行期間找到的套件列表。是否找到套件是使用 `<NAME>_FOUND` 變數確定的。

  • PACKAGES_NOT_FOUND: 在 CMake 執行期間未找到的套件列表。

    在 CMake 執行期間未找到的套件列表。是否找到套件是使用 `<NAME>_FOUND` 變數確定的。

  • REPORT_UNDEFINED_PROPERTIES: 如果設定，則將任何未定義的屬性報告到此檔案。

    如果此屬性設定為檔案名稱，則當 CMake 執行時，它會將任何被存取但未定義的屬性或變數報告到此屬性中指定的檔案名稱。

  • TARGET_ARCHIVES_MAY_BE_SHARED_LIBS: 設定是否共享程式庫可能像封存檔一樣命名。

    在 AIX 上，共享程式庫可能會命名為 `lib<name>.a`。此屬性在此類平台上設定為 true。

  • TARGET_SUPPORTS_SHARED_LIBS: 目標平台是否支援共享程式庫。

    `TARGET_SUPPORTS_SHARED_LIBS` 是一個布林值，指定目標平台是否支援共享程式庫。基本上，所有目前的通用作業系統都支援，例外通常是沒有或具有特殊作業系統的嵌入式系統。

  • __CMAKE_DELETE_CACHE_CHANGE_VARS_: 內部屬性

    用於偵測編譯器變更，請勿設定。

目錄上的屬性

  • ADDITIONAL_MAKE_CLEAN_FILES: 在 `make clean` 階段要清除的其他檔案。

    在「`make clean`」階段中將被清除的檔案列表。

  • CACHE_VARIABLES: 目前目錄中可用的快取變數列表。

    此唯讀屬性指定目前定義的 CMake 快取變數列表。它旨在用於除錯目的。

  • CLEAN_NO_CUSTOM: 是否應保留自訂命令的輸出。

    如果此值為 true，則在此目錄中自訂命令的輸出在「`make clean`」階段中不會被移除。

  • COMPILE_DEFINITIONS: 用於編譯目錄來源的預處理器定義。

    可以使用語法 `VAR` 或 `VAR=value` 將 `COMPILE_DEFINITIONS` 屬性設定為預處理器定義列表。不支援函式樣式的定義。CMake 會自動為原生建置系統正確跳脫值（請注意，CMake 語言語法可能需要跳脫才能指定某些值）。此屬性可以在每個組態的基礎上設定，方法是使用名稱 `COMPILE_DEFINITIONS_<CONFIG>`，其中 `<CONFIG>` 是大寫名稱（例如，`COMPILE_DEFINITIONS_DEBUG`）。此屬性將在每個目錄中由其在目錄父項中的值初始化。

    CMake 會自動刪除原生建置工具不支援的一些定義。VS6 IDE 不支援具有值的定義（但 NMake 支援）。

    免責聲明：大多數原生建置工具對於跳脫某些值的支援很差。CMake 對於許多情況都有解決方法，但某些值可能無法正確傳遞。如果值看起來沒有正確跳脫，請勿嘗試透過將跳脫序列新增至值來解決問題。您的解決方法可能會在未來改進了跳脫支援的 CMake 版本中損壞。相反，請考慮在（已設定的）標頭檔案中定義巨集。然後報告該限制。

  • COMPILE_DEFINITIONS_<CONFIG>: 目錄中特定組態的預處理器定義。

    這是 `COMPILE_DEFINITIONS` 的特定組態版本。此屬性將在每個目錄中由其在目錄父項中的值初始化。

  • DEFINITIONS: 僅用於 CMake 2.4 相容性。請改用 `COMPILE_DEFINITIONS`。

    此唯讀屬性指定到目前為止提供給 `add_definitions` 命令的旗標列表。它旨在用於除錯目的。請改用 `COMPILE_DEFINITIONS`。

  • EXCLUDE_FROM_ALL: 從其父項的 all 目標中排除目錄。

    目錄上的一個屬性，表示其目標是否從預設的建置目標中排除。如果沒有排除，那麼例如使用 Makefile 時，輸入 make 將會導致目標被建置。相同的概念也適用於其他產生器的預設建置。

  • IMPLICIT_DEPENDS_INCLUDE_TRANSFORM：指定目錄中相依性的 #include 行轉換。

    此屬性指定規則，用於在掃描 C 和 C++ 原始檔的隱含相依性時，轉換類似巨集的 #include 行。規則列表必須以分號分隔，每個條目的格式為 "A_MACRO(%)=value-with-%"（% 必須是字面值）。在相依性掃描期間，#include 行上出現的 A_MACRO(...) 將被替換為給定的值，並將巨集引數替換為 '%'。例如，條目

      MYDIR(%)=<mydir/%>

    ```` 

      #include MYDIR(myheader.h)

    會將以下形式的行

      #include <mydir/myheader.h>

    ````

    轉換為

  • ````

    允許追蹤相依性。

  • 此屬性適用於目錄中所有目標的來源。每個目錄中的屬性值都由其父目錄中的值初始化。

    INCLUDE_DIRECTORIES：前置處理器包含檔案搜尋目錄的列表。

  • 此唯讀屬性指定目前為止提供給 include_directories 命令的目錄列表。它用於除錯目的。

    INCLUDE_REGULAR_EXPRESSION：包含檔案掃描正規表示式。

  • 此唯讀屬性指定在相依性掃描期間用於比對應追蹤的包含檔案的正規表示式。請參閱 include_regular_expression 命令。

    LINK_DIRECTORIES：連結器搜尋目錄的列表。

  • 此唯讀屬性指定目前為止提供給 link_directories 命令的目錄列表。它用於除錯目的。

    LISTFILE_STACK：正在處理的列表檔案的目前堆疊。

  • 此屬性主要在嘗試除錯 CMake 腳本中的錯誤時很有用。它會依序返回目前正在處理的列表檔案的列表。因此，如果一個列表檔案執行 INCLUDE 命令，則實際上是將包含的列表檔案推入堆疊。

    MACROS：目前目錄中可用的巨集命令列表。

  • 此唯讀屬性指定目前定義的 CMake 巨集列表。它用於除錯目的。請參閱 macro 命令。

    PARENT_DIRECTORY：新增目前子目錄的原始碼目錄。

  • 此唯讀屬性指定將目前原始碼目錄新增為建置子目錄的原始碼目錄。在頂層目錄中，值為空字串。

    TEST_INCLUDE_FILE：當執行 ctest 時將包含的 cmake 檔案。

目標上的屬性

  • VS_SCC_PROVIDER

    WIN32_EXECUTABLE

  • XCODE_ATTRIBUTE_<an-attribute>

    <CONFIG>_POSTFIX：附加到組態 <CONFIG> 的目標檔名稱的後綴。

  • 使用組態 <CONFIG> 建置時，此屬性的值會附加到磁碟上建置的目標檔名稱。對於非執行檔目標，如果建立目標時設定了變數 CMAKE_<CONFIG>_POSTFIX，則此屬性會由此變數的值初始化。在 Mac 上，此屬性會被框架和應用程式包忽略。

    ARCHIVE_OUTPUT_DIRECTORY：建置 ARCHIVE 目標檔案的輸出目錄。

  • 此屬性指定應建置封存目標檔案的目錄。可能建置的目標檔案有三種：封存、程式庫和執行時間。可執行檔一律視為執行時間目標。靜態程式庫一律視為封存目標。模組程式庫一律視為程式庫目標。對於非 DLL 平台，共享程式庫視為程式庫目標。對於 DLL 平台，共享程式庫的 DLL 部分視為執行時間目標，而對應的匯入程式庫視為封存目標。所有基於 Windows 的系統（包括 Cygwin）都是 DLL 平台。如果建立目標時設定了變數 CMAKE_ARCHIVE_OUTPUT_DIRECTORY，則此屬性會由此變數的值初始化。

    當建置程式庫時，CMake 預設會產生程式碼，以移除所有可能名稱的任何現有程式庫。這是支援使用者選項在 STATIC 和 SHARED 之間切換的程式庫所需要的。但是，當使用 OUTPUT_NAME 使用不同的邏輯目標名稱建置名稱相同的靜態和共用程式庫時，這兩個目標將會移除彼此的檔案。可以透過將 CLEAN_DIRECT_OUTPUT 屬性設定為 1 來防止這種情況發生。

  • BUILD_WITH_INSTALL_RPATH：建置樹狀結構目標是否應具有安裝樹狀結構 rpath。

    BUILD_WITH_INSTALL_RPATH 是一個布林值，指定是否應使用 INSTALL_RPATH 將建置樹狀結構中的目標連結。這優先於 SKIP_BUILD_RPATH，並避免在安裝之前重新連結的需求。

    CMake 會自動刪除原生建置工具不支援的一些定義。VS6 IDE 不支援具有值的定義（但 NMake 支援）。

    免責聲明：大多數原生建置工具對於跳脫某些值的支援很差。CMake 對於許多情況都有解決方法，但某些值可能無法正確傳遞。如果值看起來沒有正確跳脫，請勿嘗試透過將跳脫序列新增至值來解決問題。您的解決方法可能會在未來改進了跳脫支援的 CMake 版本中損壞。相反，請考慮在（已設定的）標頭檔案中定義巨集。然後報告該限制。

  • CLEAN_DIRECT_OUTPUT：不要刪除此目標的其他變體。

    COMPILE_DEFINITIONS：用於編譯目標原始碼的前置處理器定義。

  • COMPILE_DEFINITIONS 屬性可以設定為使用語法 VAR 或 VAR=value 的前置處理器定義列表。不支援函式式定義。CMake 會自動為原生建置系統正確逸出值（請注意，CMake 語言語法可能需要逸出來指定某些值）。可以使用名稱 COMPILE_DEFINITIONS_<CONFIG> 在每個組態的基礎上設定此屬性，其中 <CONFIG> 是大寫名稱（例如，「COMPILE_DEFINITIONS_DEBUG」）。

    COMPILE_DEFINITIONS_<CONFIG>：目標上的每個組態的前置處理器定義。

  • 這是 COMPILE_DEFINITIONS 的組態特定版本。

    COMPILE_FLAGS：編譯此目標來源時要使用的其他旗標。

  • COMPILE_FLAGS 屬性設定用於建置目標內來源的其他編譯器旗標。使用 COMPILE_DEFINITIONS 傳遞其他前置處理器定義。

    DEBUG_POSTFIX：請參閱目標屬性 <CONFIG>_POSTFIX。

  • 此屬性是 DEBUG 組態的更通用 <CONFIG>_POSTFIX 屬性的特殊案例。

    DEFINE_SYMBOL：編譯此目標來源時定義一個符號。

  • DEFINE_SYMBOL 設定在共享程式庫中編譯來源時定義的前置處理器符號的名稱。如果此處未設定，則預設會設定為 target_EXPORTS（如果目標不是有效的 C 識別碼，則會進行一些替換）。這對於標頭來說很有用，可以知道它們是從其程式庫內部還是外部包含，以正確設定 dllexport/dllimport 修飾。

    ENABLE_EXPORTS：指定執行檔是否匯出用於可載入模組的符號。

  • 通常，執行檔不會匯出任何符號，因為它是最終程式。執行檔可以匯出符號以供可載入模組使用。當此屬性設定為 true 時，CMake 將允許其他目標使用 TARGET_LINK_LIBRARIES 命令「連結」到執行檔。在所有平台上，會為連結到它的目標建立執行檔的目標級別相依性。對於非 DLL 平台，連結規則會被簡單地忽略，因為動態載入器會在載入模組時自動繫結符號。對於 DLL 平台，將會為匯出的符號建立匯入程式庫，然後用於連結。所有基於 Windows 的系統（包括 Cygwin）都是 DLL 平台。

    EXCLUDE_FROM_ALL：從 all 目標排除目標。

  • 目標上的一個屬性，表示該目標是否從預設建置目標中排除。如果沒有排除，那麼例如使用 Makefile 時，輸入 make 將會導致此目標被建置。相同的概念也適用於其他產生器的預設建置。將 EXCLUDE_FROM_ALL 設定為 true 的目標安裝會產生未定義的行為。

    EchoString：建置目標時要顯示的訊息。

  • 在某些產生器（例如 makefiles）建置目標時要顯示的訊息。

    FRAMEWORK：此目標是 Mac 上的框架。

  • 如果共享程式庫目標將此屬性設定為 true，則在 Mac 上建置時，它將會建置為框架。它將具有框架所需的目錄結構，並且適合與 -framework 選項一起使用。

    Fortran_MODULE_DIRECTORY：指定目標提供的 Fortran 模組的輸出目錄。

  • 如果目標包含提供模組的 Fortran 原始檔，並且編譯器支援模組輸出目錄，則這會指定模組將放置的目錄。當此屬性未設定時，模組將放置在對應於目標原始碼目錄的建置目錄中。如果在建立目標時設定了變數 CMAKE_Fortran_MODULE_DIRECTORY，則其值會用於初始化此屬性。

    GENERATOR_FILE_NAME：此目標的產生器檔案。

  • IMPLICIT_DEPENDS_INCLUDE_TRANSFORM: 為目標中的相依性指定 #include 行轉換。

    此屬性指定規則，用於在掃描 C 和 C++ 原始檔的隱含相依性時，轉換類似巨集的 #include 行。規則列表必須以分號分隔，每個條目的格式為 "A_MACRO(%)=value-with-%"（% 必須是字面值）。在相依性掃描期間，#include 行上出現的 A_MACRO(...) 將被替換為給定的值，並將巨集引數替換為 '%'。例如，條目

      MYDIR(%)=<mydir/%>

    ```` 

      #include MYDIR(myheader.h)

    會將以下形式的行

      #include <mydir/myheader.h>

    ````

    此屬性適用於設定它的目標中的原始碼。

  • IMPORTED: 唯讀指示目標是否為 IMPORTED。

    對於使用 add_executable 或 add_library 的 IMPORTED 選項建立的目標，此屬性的布林值為 true。對於在專案內建置的目標，此值為 false。

  • IMPORTED_CONFIGURATIONS: 為 IMPORTED 目標提供的組態。

    列出適用於 IMPORTED 目標的組態名稱。這些名稱對應於匯入目標的專案中定義的組態。如果匯入專案使用不同的組態集，可以使用 MAP_IMPORTED_CONFIG_<CONFIG> 屬性來對應名稱。對於非匯入目標，會忽略此屬性。

  • IMPORTED_IMPLIB: IMPORTED 目標的匯入程式庫完整路徑。

    指定 Windows DLL 的 ".lib" 部分的位置。對於非匯入目標，會忽略此屬性。

  • IMPORTED_IMPLIB_<CONFIG>: IMPORTED_IMPLIB 屬性的每個組態版本。

    當為匯入目標的 <CONFIG> 組態載入設定時，會使用此屬性。組態名稱對應於匯入目標的專案所提供的組態名稱。

  • IMPORTED_LINK_DEPENDENT_LIBRARIES: 匯入的共享程式庫的相依共享程式庫。

    共享程式庫可能會連結到其他共享程式庫，作為其實作的一部分。在某些平台上，連結器會搜尋連結中包含的共享程式庫的相依程式庫。此屬性會列出匯入程式庫的相依共享程式庫。此清單應與 IMPORTED_LINK_INTERFACE_LIBRARIES 屬性中的介面程式庫清單不相交。在需要於連結時找到相依共享程式庫的平台上，CMake 會使用此清單將適當的檔案或路徑新增至連結命令列。對於非匯入目標，會忽略此屬性。

  • IMPORTED_LINK_DEPENDENT_LIBRARIES_<CONFIG>: IMPORTED_LINK_DEPENDENT_LIBRARIES 的每個組態版本。

    當為匯入目標的 <CONFIG> 組態載入設定時，會使用此屬性。組態名稱對應於匯入目標的專案所提供的組態名稱。如果設定了此屬性，則會完全覆寫指定組態的通用屬性。

  • IMPORTED_LINK_INTERFACE_LIBRARIES: IMPORTED 目標的遞移連結介面。

    列出當 IMPORTED 程式庫目標連結到另一個目標時，其介面會包含在內的程式庫。這些程式庫將包含在目標的連結行上。與 LINK_INTERFACE_LIBRARIES 屬性不同，此屬性適用於所有匯入目標類型，包括 STATIC 程式庫。對於非匯入目標，會忽略此屬性。

  • IMPORTED_LINK_INTERFACE_LIBRARIES_<CONFIG>: IMPORTED_LINK_INTERFACE_LIBRARIES 的每個組態版本。

    當為匯入目標的 <CONFIG> 組態載入設定時，會使用此屬性。組態名稱對應於匯入目標的專案所提供的組態名稱。如果設定了此屬性，則會完全覆寫指定組態的通用屬性。

  • IMPORTED_LOCATION: IMPORTED 目標在磁碟上的主要檔案完整路徑。

    指定 IMPORTED 目標檔案在磁碟上的位置。對於可執行檔，這是可執行檔的位置。對於 OS X 上的套件，這是應用程式套件資料夾下 Contents/MacOS 內的可執行檔位置。對於靜態程式庫和模組，這是程式庫或模組的位置。對於非 DLL 平台上的共享程式庫，這是共享程式庫的位置。對於 OS X 上的框架，這是框架資料夾內程式庫檔案符號連結的位置。對於 DLL，這是程式庫的 ".dll" 部分的位置。對於 UNKNOWN 程式庫，這是要連結的檔案位置。對於非匯入目標，會忽略此屬性。

  • IMPORTED_LOCATION_<CONFIG>: IMPORTED_LOCATION 屬性的每個組態版本。

    當為匯入目標的 <CONFIG> 組態載入設定時，會使用此屬性。組態名稱對應於匯入目標的專案所提供的組態名稱。

  • IMPORTED_SONAME: 共享程式庫類型的 IMPORTED 目標的「soname」。

    指定內嵌在匯入的共享程式庫中的「soname」。這僅在支援此功能的平台上才有意義。對於非匯入目標，會忽略此屬性。

  • IMPORTED_SONAME_<CONFIG>: IMPORTED_SONAME 屬性的每個組態版本。

    當為匯入目標的 <CONFIG> 組態載入設定時，會使用此屬性。組態名稱對應於匯入目標的專案所提供的組態名稱。

  • IMPORT_PREFIX: 匯入程式庫名稱之前的文字。

    類似於目標屬性 PREFIX，但用於匯入程式庫（通常對應於 DLL），而非一般程式庫。一個目標屬性，可以設定以覆寫匯入程式庫名稱上的前置詞（例如 "lib"）。

  • IMPORT_SUFFIX: 匯入程式庫名稱之後的文字。

    類似於目標屬性 SUFFIX，但用於匯入程式庫（通常對應於 DLL），而非一般程式庫。一個目標屬性，可以設定以覆寫匯入程式庫名稱上的後置詞（例如 ".lib"）。

  • INSTALL_NAME_DIR: Mac OSX 已安裝目標的目錄名稱。

    INSTALL_NAME_DIR 是一個字串，指定 Mac OSX 上共享程式庫的 "install_name" 欄位的目錄部分，用於已安裝的目標。

  • INSTALL_RPATH: 用於已安裝目標的 rpath。

    一個以分號分隔的清單，指定用於已安裝目標的 rpath（適用於支援此功能的平台）。

  • INSTALL_RPATH_USE_LINK_PATH: 將路徑新增至連結器搜尋和已安裝的 rpath。

    INSTALL_RPATH_USE_LINK_PATH 是一個布林值，如果設定為 true，則會將連結器搜尋路徑中以及專案外部的目錄附加到 INSTALL_RPATH。

  • LIBRARY_OUTPUT_DIRECTORY: 建置 LIBRARY 目標檔案的輸出目錄。

    此屬性指定應該在其中建置程式庫目標檔案的目錄。可能會建置三種目標檔案：封存檔、程式庫和執行階段。可執行檔始終被視為執行階段目標。靜態程式庫始終被視為封存目標。模組程式庫始終被視為程式庫目標。對於非 DLL 平台，共享程式庫被視為程式庫目標。對於 DLL 平台，共享程式庫的 DLL 部分被視為執行階段目標，而對應的匯入程式庫被視為封存目標。所有基於 Windows 的系統（包括 Cygwin）都是 DLL 平台。如果在建立目標時設定了變數 CMAKE_LIBRARY_OUTPUT_DIRECTORY，則會使用此變數的值初始化此屬性。

  • LINKER_LANGUAGE: 根據語言使用哪個工具進行連結。

    LINKER_LANGUAGE 屬性用於變更用於連結可執行檔或共用程式庫的工具。預設設定語言以符合程式庫中的檔案。CXX 和 C 是此屬性的常見值。

  • LINK_FLAGS: 連結此目標時要使用的其他旗標。

    LINK_FLAGS 屬性可用於將額外的旗標新增至目標的連結步驟。LINK_FLAGS_<CONFIG> 將新增至組態 <CONFIG>，例如 DEBUG、RELEASE、MINSIZEREL、RELWITHDEBINFO。

  • LINK_FLAGS_<CONFIG>: 目標的每個組態連結器旗標。

    這是 LINK_FLAGS 的組態特定版本。

  • LINK_INTERFACE_LIBRARIES: 共享程式庫或可執行檔的公開介面程式庫清單。

    預設情況下，連結到共享程式庫目標會遞移連結到該程式庫本身連結的目標。對於具有匯出的可執行檔（請參閱 ENABLE_EXPORTS 屬性），不使用預設的遞移連結相依性。此屬性會以明確的清單取代預設的遞移連結相依性。當目標連結到另一個目標時，也會將列出的程式庫（以及遞迴的連結介面程式庫）提供給另一個目標。如果清單為空，則當此目標連結到另一個目標時，即使預設集合不為空，也不會合併任何遞移連結相依性。對於 STATIC 程式庫，會忽略此屬性。

  • LINK_INTERFACE_LIBRARIES_<CONFIG>: 目標的每個組態公開介面程式庫清單。

    這是 LINK_INTERFACE_LIBRARIES 的組態特定版本。如果設定了此屬性，則會完全覆寫指定組態的通用屬性。

  • LINK_SEARCH_END_STATIC: 結束連結行，以便使用靜態系統程式庫。

    某些連結器支援諸如 -Bstatic 和 -Bdynamic 之類的開關，以確定是否對 -lXXX 選項使用靜態或共享程式庫。CMake 使用這些選項來設定程式庫的連結類型，這些程式庫的完整路徑未知，或者（在某些情況下）位於平台的隱含連結目錄中。預設情況下，在程式庫清單結束時，連結器搜尋類型將保留在 -Bdynamic。此屬性會將最終的連結器搜尋類型切換為 -Bstatic。

  • LOCATION: 目標在磁碟上的唯讀位置。

    對於匯入的目標，此唯讀屬性會針對目標提供的未指定組態 <CONFIG> 傳回 LOCATION_<CONFIG> 屬性的值。

    對於非匯入的目標，提供此屬性是為了與 CMake 2.4 及更早版本相容。它是為了取得可執行目標的輸出檔案位置，以用於 add_custom_command。路徑可能包含一個建置系統特定的部分，該部分會在建置時被正在建置的組態取代（例如 VS 中的 "$(ConfigurationName)"）。在 CMake 2.6 及更高版本中，add_custom_command 會自動識別其 COMMAND 和 DEPENDS 選項中的目標名稱，並計算目標位置。因此，建立自訂命令不需要此屬性。

  • LOCATION_<CONFIG>: 提供目標在磁碟上的位置的唯讀屬性。

    一個唯讀屬性，表示目標的主要檔案在磁碟上對於組態 <CONFIG> 的位置。此屬性僅針對程式庫和可執行目標定義。匯入的目標可能會提供一組與匯入專案不同的組態。預設情況下，CMake 會尋找完全匹配的組態，否則會使用任意可用的組態。使用 MAP_IMPORTED_CONFIG_<CONFIG> 屬性來明確對應匯入的組態。

  • MACOSX_BUNDLE：在 Mac OS X 上將可執行檔建置為應用程式套件。

    當此屬性設定為 true 時，在 Mac OS X 上建置的可執行檔將會建立為應用程式套件。這使其成為可從 Finder 啟動的 GUI 可執行檔。請參閱 MACOSX_BUNDLE_INFO_PLIST 目標屬性，以取得有關應用程式套件的 Info.plist 檔案建立資訊。

  • MACOSX_BUNDLE_INFO_PLIST：為 Mac OS X 應用程式套件指定自訂的 Info.plist 範本。

    已啟用 MACOSX_BUNDLE 的可執行檔目標將會在 Mac OS X 上建置為應用程式套件。預設情況下，其 Info.plist 檔案是透過設定位於 CMAKE_MODULE_PATH 中的名為 MacOSXBundleInfo.plist.in 的範本來建立的。此屬性指定一個替代範本檔案名稱，可以是完整路徑。

    可以設定以下目標屬性來指定要設定到檔案中的內容

      MACOSX_BUNDLE_INFO_STRING
      MACOSX_BUNDLE_ICON_FILE
      MACOSX_BUNDLE_GUI_IDENTIFIER
      MACOSX_BUNDLE_LONG_VERSION_STRING
      MACOSX_BUNDLE_BUNDLE_NAME
      MACOSX_BUNDLE_SHORT_VERSION_STRING
      MACOSX_BUNDLE_BUNDLE_VERSION
      MACOSX_BUNDLE_COPYRIGHT

    可以設定具有相同名稱的 CMake 變數，以影響目錄中沒有設定每個特定屬性的所有目標。如果此屬性指定了自訂的 Info.plist，當然可以硬式編碼所有設定，而不是使用目標屬性。

  • MACOSX_FRAMEWORK_INFO_PLIST：為 Mac OS X 框架指定自訂的 Info.plist 範本。

    已啟用 FRAMEWORK 的程式庫目標將會在 Mac OS X 上建置為框架。預設情況下，其 Info.plist 檔案是透過設定位於 CMAKE_MODULE_PATH 中的名為 MacOSXFrameworkInfo.plist.in 的範本來建立的。此屬性指定一個替代範本檔案名稱，可以是完整路徑。

    可以設定以下目標屬性來指定要設定到檔案中的內容

      MACOSX_FRAMEWORK_ICON_FILE
      MACOSX_FRAMEWORK_IDENTIFIER
      MACOSX_FRAMEWORK_SHORT_VERSION_STRING
      MACOSX_FRAMEWORK_BUNDLE_VERSION

    可以設定具有相同名稱的 CMake 變數，以影響目錄中沒有設定每個特定屬性的所有目標。如果此屬性指定了自訂的 Info.plist，當然可以硬式編碼所有設定，而不是使用目標屬性。

  • MAP_IMPORTED_CONFIG_<CONFIG>：從專案組態對應到 IMPORTED 目標的組態。

    列出匯入目標的組態，這些組態可用於目前專案的 <CONFIG> 組態。從另一個專案匯入的目標可能不會提供目前專案中可用的相同組態名稱集合。設定此屬性會告知 CMake 在建置 <CONFIG> 組態時，哪些匯入組態適合使用。將會選取匯入目標提供的列表中找到的第一個組態。如果沒有可用的符合組態，則會認為找不到匯入目標。對於非匯入目標，此屬性會被忽略。

  • OUTPUT_NAME：設定目標建置時的實際名稱。

    設定目標建置時的實際名稱，可用於協助建立兩個名稱相同的目標，即使 CMake 要求唯一的邏輯目標名稱。還有一個 <CONFIG>_OUTPUT_NAME，可以在每個組態的基礎上設定輸出名稱。

  • POST_INSTALL_SCRIPT：已棄用的安裝支援。

    PRE_INSTALL_SCRIPT 和 POST_INSTALL_SCRIPT 屬性是指定要在安裝目標之前和之後執行的 CMake 指令碼的舊方法。它們僅在使用舊的 INSTALL_TARGETS 命令來安裝目標時使用。請改用 INSTALL 命令。

  • PREFIX：程式庫名稱之前的前置詞。

    一個可以設定的目標屬性，以覆寫程式庫名稱上的前置詞（例如 "lib"）。

  • PRE_INSTALL_SCRIPT：已棄用的安裝支援。

    PRE_INSTALL_SCRIPT 和 POST_INSTALL_SCRIPT 屬性是指定要在安裝目標之前和之後執行的 CMake 指令碼的舊方法。它們僅在使用舊的 INSTALL_TARGETS 命令來安裝目標時使用。請改用 INSTALL 命令。

  • PRIVATE_HEADER：在 FRAMEWORK 共用程式庫目標中指定私有標頭檔。

    使用 FRAMEWORK 屬性標記的共用程式庫目標會在 OS X 上產生框架，在其他平台上產生正常的共用程式庫。可以將此屬性設定為要放置在框架資料夾內 PrivateHeaders 目錄中的標頭檔清單。在非 Apple 平台上，可以使用 install(TARGETS) 命令的 PRIVATE_HEADER 選項來安裝這些標頭。

  • PROJECT_LABEL：變更 IDE 中目標的名稱。

    可用於變更 IDE 中（如 Visual Studio）目標的名稱。

  • PUBLIC_HEADER：在 FRAMEWORK 共用程式庫目標中指定公用標頭檔。

    使用 FRAMEWORK 屬性標記的共用程式庫目標會在 OS X 上產生框架，在其他平台上產生正常的共用程式庫。可以將此屬性設定為要放置在框架資料夾內 Headers 目錄中的標頭檔清單。在非 Apple 平台上，可以使用 install(TARGETS) 命令的 PUBLIC_HEADER 選項來安裝這些標頭。

  • RESOURCE：在 FRAMEWORK 共用程式庫目標中指定資源檔案。

    使用 FRAMEWORK 屬性標記的共用程式庫目標會在 OS X 上產生框架，在其他平台上產生正常的共用程式庫。可以將此屬性設定為要放置在框架資料夾內 Resources 目錄中的檔案清單。在非 Apple 平台上，可以使用 install(TARGETS) 命令的 RESOURCE 選項來安裝這些檔案。

  • RUNTIME_OUTPUT_DIRECTORY：建置 RUNTIME 目標檔案的輸出目錄。

    此屬性指定應該將 runtime 目標檔案建置到的目錄。可以建置三種目標檔案：封存檔、程式庫和執行階段。可執行檔始終被視為執行階段目標。靜態程式庫始終被視為封存檔目標。模組程式庫始終被視為程式庫目標。對於非 DLL 平台，共用程式庫被視為程式庫目標。對於 DLL 平台，共用程式庫的 DLL 部分被視為執行階段目標，而對應的匯入程式庫被視為封存檔目標。包括 Cygwin 在內的所有基於 Windows 的系統都是 DLL 平台。如果 CMAKE_RUNTIME_OUTPUT_DIRECTORY 變數在建立目標時已設定，則此屬性會由此變數的值初始化。

  • SKIP_BUILD_RPATH：是否應為建置樹狀結構使用 rpath。

    SKIP_BUILD_RPATH 是一個布林值，用於指定是否跳過自動產生 rpath，以允許目標從建置樹狀結構中執行。

  • SOURCES：為目標指定的來源名稱。

    為目標指定的來源唯讀清單。傳回的名稱適用於傳遞給 set_source_files_properties 命令。

  • SOVERSION：此目標的版本號碼。

    對於共用程式庫，可以使用 VERSION 和 SOVERSION 分別指定建置版本和 API 版本。當建置或安裝時，如果平台支援符號連結且連結器支援 so-name，則會建立適當的符號連結。如果僅指定其中一個，則假設遺失的版本號碼相同。對於 Windows 上的共用程式庫和可執行檔，將會剖析 VERSION 屬性以提取 "major.minor" 版本號碼。這些數字會用作二進位檔的映像版本。

  • STATIC_LIBRARY_FLAGS：連結靜態程式庫時要使用的額外旗標。

    連結靜態程式庫時要使用的額外旗標。

  • SUFFIX：程式庫名稱之後的後綴詞。

    一個可以設定的目標屬性，以覆寫程式庫名稱上的後綴詞（例如 ".so"）。

  • TYPE：目標的類型。

    此唯讀屬性可用於測試給定目標的類型。它將是 STATIC_LIBRARY、MODULE_LIBRARY、SHARED_LIBRARY、EXECUTABLE 或其中一個內部目標類型。

  • VERSION：此目標的版本號碼。

    對於共用程式庫，可以使用 VERSION 和 SOVERSION 分別指定建置版本和 API 版本。當建置或安裝時，如果平台支援符號連結且連結器支援 so-names，則會建立適當的符號連結。如果僅指定其中一個，則會假設遺失的版本號碼相同。對於可執行檔，可以使用 VERSION 指定建置版本。當建置或安裝時，如果平台支援符號連結，則會建立適當的符號連結。對於 Windows 上的共用程式庫和可執行檔，會剖析 VERSION 屬性以擷取「major.minor」版本號碼。這些數字用作二進位的影像版本。

  • VS_KEYWORD：Visual Studio 專案關鍵字。

    可以設定為變更 Visual Studio 關鍵字，例如，如果設定為 Qt4VSv1.0，則 QT 整合效果會更好。

  • VS_SCC_LOCALPATH：Visual Studio 原始碼控制提供者。

    可以設定為變更 Visual Studio 原始碼控制本機路徑屬性。

  • VS_SCC_PROJECTNAME：Visual Studio 原始碼控制專案。

    可以設定為變更 Visual Studio 原始碼控制專案名稱屬性。

  • VS_SCC_PROVIDER：Visual Studio 原始碼控制提供者。

    可以設定為變更 Visual Studio 原始碼控制提供者屬性。

  • WIN32_EXECUTABLE：在 Windows 上使用 WinMain 進入點建置可執行檔。

    當此屬性設定為 true 時，在 Windows 上連結的可執行檔將會建立具有 WinMain() 進入點，而不是只有 main()。這使其成為 GUI 可執行檔，而不是主控台應用程式。請參閱 CMAKE_MFC_FLAG 變數文件，以設定 WinMain 可執行檔的 MFC 使用。

  • XCODE_ATTRIBUTE_<an-attribute>：直接設定 Xcode 目標屬性。

    告知 Xcode 產生器在產生的 Xcode 專案中將 '<an-attribute>' 設定為給定值。在其他產生器上忽略。

測試上的屬性

  • FAIL_REGULAR_EXPRESSION：如果輸出與此正規表示式匹配，則測試將會失敗。

    如果設定，如果輸出與指定的其中一個正規表示式匹配，則測試將會失敗。例如：PASS_REGULAR_EXPRESSION "[^a-z]Error;ERROR;Failed"

  • MEASUREMENT：指定要針對測試報告的 DART 量測和值。

    如果設定為名稱，則該名稱將會以數值 1 的名稱量測報告給 DART。您也可以將 MEASUREMENT 設定為 "measurement=value" 來指定值。

  • PASS_REGULAR_EXPRESSION：輸出必須與此正規表示式匹配，測試才能通過。

    如果設定，將會針對指定的正規表示式檢查測試輸出，並且必須至少有一個正規表示式匹配，否則測試將會失敗。

  • TIMEOUT：此測試允許執行的秒數。

    如果設定此屬性，則會限制測試的執行時間不得超過指定的秒數。如果超過該時間，則測試程序將會被終止，而 ctest 將會移至下一個測試。此設定優先於 DART_TESTING_TIMEOUT 和 CTEST_TESTING_TIMEOUT。

  • WILL_FAIL：如果設定為 true，則會反轉測試的通過/失敗旗標。

    此屬性可用於預期會失敗且傳回非零傳回碼的測試。

原始程式檔上的屬性

  • ABSTRACT：此來源檔案是否為抽象類別。

    來源檔案上的屬性，用於指出來源檔案是否代表抽象類別。這僅對具有抽象類別概念的語言才有意義，並且僅由某些將類別包裝到其他語言的工具使用。

  • COMPILE_DEFINITIONS：用於編譯來源檔案的預處理器定義。

    BUILD_WITH_INSTALL_RPATH 是一個布林值，指定是否應使用 INSTALL_RPATH 將建置樹狀結構中的目標連結。這優先於 SKIP_BUILD_RPATH，並避免在安裝之前重新連結的需求。

    CMake 將會自動捨棄原生建置工具不支援的一些定義。VS6 IDE 不支援帶有值的定義（但 NMake 支援）。Xcode 不支援來源檔案上的每個組態定義。

    免責聲明：大多數原生建置工具對於跳脫某些值的支援很差。CMake 對於許多情況都有解決方法，但某些值可能無法正確傳遞。如果值看起來沒有正確跳脫，請勿嘗試透過將跳脫序列新增至值來解決問題。您的解決方法可能會在未來改進了跳脫支援的 CMake 版本中損壞。相反，請考慮在（已設定的）標頭檔案中定義巨集。然後報告該限制。

  • COMPILE_DEFINITIONS_<CONFIG>：來源檔案上每個組態的預處理器定義。

    這是 COMPILE_DEFINITIONS 的組態特定版本。請注意，Xcode 不支援每個組態的來源檔案旗標，因此 Xcode 產生器會忽略此屬性。

  • COMPILE_FLAGS：編譯此來源檔案時要新增的額外旗標。

    當建置此來源檔案時，這些旗標將會新增至編譯旗標清單。使用 COMPILE_DEFINITIONS 來傳遞其他預處理器定義。

  • EXTERNAL_OBJECT：如果設定為 true，則表示這是一個物件檔案。

    如果此屬性設定為 true，則來源檔案實際上是一個物件檔案，不應進行編譯。它仍然會連結到目標中。

  • GENERATED: 此原始檔是否為建置過程的一部分而產生。

    如果原始檔是由建置過程產生，CMake 會在相依性檢查等方面以不同的方式處理它。否則，使用不存在的原始檔可能會產生問題。

  • HEADER_FILE_ONLY: 此原始檔是否僅為標頭檔。

    原始檔的屬性，指示該原始檔是否為沒有相關實作的標頭檔。此屬性會根據檔案副檔名自動設定，並由 CMake 用於判斷是否應計算某些相依性資訊。

  • KEEP_EXTENSION: 使輸出檔的副檔名與原始檔相同。

    如果設定此屬性，則輸出檔的副檔名將與原始檔的副檔名相同。通常，輸出檔的副檔名會根據原始檔的語言來計算，例如 .cxx 會變成 .o 副檔名。

  • LANGUAGE: 此檔案的程式語言為何。

    可以設定的屬性，以指示原始檔的程式語言為何。如果未設定，則會根據檔案副檔名決定語言。典型值為 CXX、C 等。

  • LOCATION: 原始檔的完整路徑。

    SOURCE FILE 的唯讀屬性，其中包含原始檔的完整路徑。

  • MACOSX_PACKAGE_LOCATION: 將原始檔放置在 Mac OS X 套件或框架內。

    具有設定 MACOSX_BUNDLE 屬性的可執行目標檔，會在 Apple 平台上建置為 Mac OS X 應用程式套件。具有設定 FRAMEWORK 屬性的共享程式庫目標檔，會在 Apple 平台上建置為 Mac OS X 框架。具有設定此屬性的目標檔中列出的原始檔，將會複製到套件或框架內容資料夾內由屬性值指定的目錄中。對於套件，內容資料夾為「<名稱>.app/Contents」。對於框架，內容資料夾為「<名稱>.framework/Versions/<版本>」。如需指定用於 Headers、PrivateHeaders 或 Resources 目錄的檔案，請參閱 PUBLIC_HEADER、PRIVATE_HEADER 和 RESOURCE 目標屬性。

  • OBJECT_DEPENDS: 編譯後的目標檔所依賴的其他檔案。

    指定以分號分隔的完整路徑檔案清單，編譯自此原始檔的任何目標檔都依賴這些檔案。如果任何指定檔案比目標檔新，則會重新編譯目標檔。

    此屬性不需用於指定原始檔對其包含的已產生標頭檔的相依性。雖然此屬性最初是為此目的而引入，但現在已不再需要。如果已產生標頭檔是由與原始檔相同的目標檔中的自訂命令建立，則自動相依性掃描程序會識別相依性。如果已產生標頭檔是由另一個目標檔建立，則應該使用 add_dependencies 命令建立目標間相依性（如果由於連結關係而尚未存在）。

  • OBJECT_OUTPUTS: Makefile 規則的其他輸出。

    編譯此原始檔所建立的其他輸出。如果缺少任何這些輸出，將會重新編譯目標檔。這僅在 Makefile 產生器上支援，並且會在其他產生器上忽略。

  • SYMBOLIC: 這是否僅為規則的名稱。

    如果 SYMBOLIC (布林值) 設定為 true，則會通知建置系統，該原始檔實際上不是在磁碟上建立，而是用作建置規則的符號名稱。

  • WRAP_EXCLUDE: 將此原始檔排除在任何程式碼包裝技術之外。

    某些套件可以將原始檔包裝成替代語言，以提供其他功能。例如，可以使用 SWIG 等將 C++ 程式碼包裝成 Java 或 Python 等。如果 WRAP_EXCLUDE 設定為 true (1 等)，則表示不應包裝此原始檔。

相容性命令

  CMake Compatibility Listfile Commands - Obsolete commands supported by CMake for compatibility.

這是先前 CMake 版本中現已過時的清單檔命令的文件，為了相容性原因仍然支援這些命令。您應該改用更新、更快且更精美的新命令。;-)

  • build_name: 已過時。請改用 ${CMAKE_SYSTEM} 和 ${CMAKE_CXX_COMPILER}。
      build_name(variable)

    將指定的變數設定為代表平台和編譯器設定的字串。這些值現在可透過 CMAKE_SYSTEM 和 CMAKE_CXX_COMPILER 變數取得。

  • exec_program: 已過時。請改用 execute_process() 命令。

    在處理 CMakeList.txt 檔案期間執行可執行程式。

      exec_program(Executable [directory in which to run]
                   [ARGS <arguments to executable>]
                   [OUTPUT_VARIABLE <var>]
                   [RETURN_VALUE <var>])

    可執行程式會在選擇性指定的目錄中執行。如果可執行程式用雙引號括住，則可以包含引數，但最好使用選擇性引數 ARGS 來指定程式的引數。這是因為 cmake 隨後可以跳脫可執行程式路徑中的空格。選擇性引數 OUTPUT_VARIABLE 會指定儲存輸出的變數。若要擷取執行的傳回值，請提供 RETURN_VALUE。如果指定 OUTPUT_VARIABLE，則不會有任何輸出到執行 cmake 的主控台的 stdout/stderr。

  • export_library_dependencies: 已過時。請使用 INSTALL(EXPORT) 或 EXPORT 命令。

    此命令會產生舊式的程式庫相依性檔案。需要 CMake 2.6 或更高版本的專案不應使用此命令。請改用 install(EXPORT) 命令來協助從安裝樹狀結構匯出目標檔，並使用 export() 命令從建置樹狀結構匯出目標檔。

    舊式程式庫相依性檔案不考慮程式庫的每個組態名稱或 LINK_INTERFACE_LIBRARIES 目標屬性。

      export_library_dependencies(<file> [APPEND])

    建立名為 <檔案> 的檔案，可以使用 INCLUDE 命令將其包含到 CMake 清單檔中。該檔案將包含許多 SET 命令，這些命令會設定程式庫相依性資訊所需的所有變數。這應該是專案最上層 CMakeLists.txt 檔案中的最後一個命令。如果指定 APPEND 選項，則 SET 命令會附加到給定的檔案，而不是取代它。

  • install_files: 已過時。請改用 install(FILES ) 命令。

    此命令已被 install 命令取代。提供此命令是為了與較舊的 CMake 程式碼相容。FILES 形式會直接由 install 命令的 FILES 形式取代。可以使用 file 命令的 GLOB 形式更清楚地表示 regexp 形式。

      install_files(<dir> extension file file ...)

    建立規則，以將列出的檔案與給定的副檔名安裝到給定的目錄中。只能列出存在於目前原始檔樹狀結構或其在二進位樹狀結構中對應位置的檔案。如果指定的檔案已具有副檔名，則會先移除該副檔名。這對於提供原始檔清單很有用，例如 foo.cxx，當您想要安裝對應的 foo.h 時。典型的副檔名為 '.h'。

      install_files(<dir> regexp)

    目前原始檔目錄中與規則運算式相符的任何檔案都將被安裝。

      install_files(<dir> FILES file file ...)

    FILES 關鍵字之後列出的任何檔案都會從給定的名稱明確安裝。允許在此形式中使用完整路徑。

    目錄 <目錄> 相對於安裝前置詞，該前置詞儲存在變數 CMAKE_INSTALL_PREFIX 中。

  • install_programs: 已過時。請改用 install(PROGRAMS ) 命令。

    此命令已被 install 命令取代。提供此命令是為了與較舊的 CMake 程式碼相容。FILES 形式會直接由 INSTALL 命令的 PROGRAMS 形式取代。可以使用 FILE 命令的 GLOB 形式更清楚地表示 regexp 形式。

      install_programs(<dir> file1 file2 [file3 ...])
      install_programs(<dir> FILES file1 [file2 ...])

    建立規則，以將列出的程式安裝到給定的目錄中。使用 FILES 引數來保證即使只有一個引數，也會使用命令的檔案清單版本。

      install_programs(<dir> regexp)

    在第二種形式中，目前原始檔目錄中與規則運算式相符的任何程式都會被安裝。

    此命令旨在安裝不是由 cmake 建置的程式，例如 shell 腳本。請參閱 INSTALL 命令的 TARGETS 形式，以建立 cmake 建置目標檔的安裝規則。

    目錄 <目錄> 相對於安裝前置詞，該前置詞儲存在變數 CMAKE_INSTALL_PREFIX 中。

  • install_targets: 已過時。請改用 install(TARGETS ) 命令。

    此命令已被 install 命令取代。提供此命令是為了與較舊的 CMake 程式碼相容。

      install_targets(<dir> [RUNTIME_DIRECTORY dir] target target)

    建立規則，以將列出的目標檔安裝到給定的目錄中。目錄 <目錄> 相對於安裝前置詞，該前置詞儲存在變數 CMAKE_INSTALL_PREFIX 中。如果指定 RUNTIME_DIRECTORY，則在具有特殊執行階段檔案的系統上 (Windows DLL)，這些檔案將會複製到該目錄中。

  • link_libraries: 已過時。請改用 target_link_libraries() 命令。

    將程式庫連結到稍後新增的所有目標檔。

      link_libraries(library1 <debug | optimized> library2 ...)

    指定要連結到任何後續目標檔的程式庫清單（通常使用 add_executable 或 add_library 呼叫新增）。此命令會傳遞到所有子目錄。debug 和 optimized 字串可用於指示列出的下一個程式庫僅適用於該特定類型的建置。

  • make_directory: 已過時。請改用 file(MAKE_DIRECTORY ) 命令。
      make_directory(directory)

    建立指定的目錄。應提供完整路徑。也會建立任何不存在的父目錄。謹慎使用。

  • remove: 已過時。請改用 list(REMOVE_ITEM ) 命令。
      remove(VAR VALUE VALUE ...)

    從變數 VAR 中移除 VALUE。這通常用於從向量中移除項目 (例如，以分號分隔的清單)。會展開 VALUE。

  • subdir_depends: 已過時。不執行任何操作。
      subdir_depends(subdir dep1 dep2 ...)

    不執行任何操作。此命令過去用於協助專案正確排序平行建置。此功能現在是自動的。

  • subdirs: 已過時。請改用 add_subdirectory() 命令。

    將子目錄清單新增到建置。

      subdirs(dir1 dir2 ...[EXCLUDE_FROM_ALL exclude_dir1 exclude_dir2 ...] [PREORDER] )

    將子目錄清單新增到建置。應該使用 add_subdirectory 命令，而不是 subdirs，雖然 subdirs 仍然有效。這會導致 CMake 處理子目錄中的任何 CMakeLists.txt 檔案。makefile 建置會首先遍歷 PREORDER 旗標之後的任何目錄，PREORDER 旗標對 IDE 專案沒有影響。EXCLUDE_FROM_ALL 標記之後的任何目錄都不會包含在最上層 makefile 或專案檔案中。這對於讓 CMake 為專案中的一組範例建立 makefile 或專案非常有用。您會希望 CMake 同時為所有範例產生 makefile 或專案檔案，但您不會希望它們顯示在最上層專案中，或每次從最上層執行 make 時都建置它們。

  • use_mangled_mesa: 複製 mesa 標頭，以便與系統 GL 搭配使用。
      use_mangled_mesa(PATH_TO_MESA OUTPUT_DIRECTORY)

    mesa 包含的路徑應該包含 gl_mangle.h。mesa 標頭會複製到指定的輸出目錄。這允許通過更早新增到包含目錄路徑來讓已更名的 mesa 標頭覆寫其他 GL 標頭。

  • utility_source: 指定協力廠商公用程式的原始檔樹狀結構。
      utility_source(cache_entry executable_name
                     path_to_source [file1 file2 ...])

    當協力廠商公用程式的原始檔包含在發行版本中時，此命令會指定其位置和名稱。除非 path_to_source 和所有列出的檔案都存在，否則不會設定快取項目。假設公用程式的原始檔樹狀結構已在需要之前建置。

    當交叉編譯時，如果執行了 `utility_source()` 命令，CMake 會印出警告，因為在許多情況下，它被用來建置一個稍後執行的執行檔。這在交叉編譯時會失效，因為該執行檔只能在目標平台上執行。因此，在這種情況下，必須手動調整快取條目，使其指向一個可在建置主機上執行的執行檔。

  • variable_requires：已棄用。請改用 if() 命令。

    斷言選項所需變數的滿足情況。

      variable_requires(TEST_VARIABLE RESULT_VARIABLE
                        REQUIRED_VARIABLE1
                        REQUIRED_VARIABLE2 ...)

    第一個引數 (TEST_VARIABLE) 是要測試的變數名稱，如果該變數為 false，則不會執行任何其他動作。如果 TEST_VARIABLE 為 true，則下一個引數 (RESULT_VARIABLE) 是一個變數，如果所有必需的變數都已設定，則該變數會設為 true。其餘的引數是必須為 true 或未設定為 NOTFOUND 的變數，以避免錯誤。如果任何一個不是 true，則會報告錯誤。

  • write_file：已棄用。請改用 file(WRITE) 命令。
      write_file(filename "message to write"... [APPEND])

    第一個引數是檔案名稱，其餘的引數是要寫入的訊息。如果指定了 APPEND 引數，則訊息將會附加在檔案末尾。

    注意 1：`file(WRITE ...)` 和 `file(APPEND ...)` 的功能與此完全相同，但增加了一些額外的功能。

    注意 2：使用 `write_file` 時，產生的檔案不能用作 CMake 的輸入 (CONFIGURE_FILE、原始檔...)，因為這會導致無限迴圈。如果要產生 CMake 的輸入檔案，請使用 `configure_file`。

標準 CMake 模組

以下模組由 CMake 提供。它們可以使用 `INCLUDE(ModuleName)` 來使用。

  CMake Modules - Modules coming with CMake, the Cross-Platform Makefile Generator.

這是關於 CMake 隨附的模組和腳本的文件。使用這些模組，您可以檢查電腦系統中已安裝的軟體套件、編譯器的功能以及標頭的存在，僅舉幾例。

  • AddFileDependencies：ADD_FILE_DEPENDENCIES(source_file depend_files...)

    將給定的檔案新增為 source_file 的相依性。

  • BundleUtilities:

    BundleUtilities.cmake

    一系列 CMake 實用函式，可用於處理 Mac 上的 .app 捆綁包和任何作業系統上的類似捆綁包的目錄。

    此腳本提供以下函式

       get_bundle_main_executable
       get_dotapp_dir
       get_bundle_and_executable
       get_bundle_all_executables
       get_item_key
       clear_bundle_keys
       set_bundle_key_values
       get_bundle_keys
       copy_resolved_item_into_bundle
       fixup_bundle_item
       fixup_bundle
       copy_and_fixup_bundle
       verify_bundle_prerequisites
       verify_bundle_symlinks
       verify_app


    需要 CMake 2.6 或更高版本，因為它使用 function、break 和 PARENT_SCOPE。也相依於 GetPrerequisites.cmake。

  • CMakeASM-ATTInformation:

    支援 AT&T 語法組譯器，例如 GNU as

  • CMakeASM_MASMInformation:

    支援 MS 組譯器，masm 和 masm64

  • CMakeBackwardCompatibilityCXX：定義一組向後相容的變數
      CMAKE_ANSI_CXXFLAGS - flag for ansi c++ 
      CMAKE_HAS_ANSI_STRING_STREAM - has <strstream>
      INCLUDE(TestForANSIStreamHeaders)
      INCLUDE(CheckIncludeFileCXX)
      INCLUDE(TestForSTDNamespace)
      INCLUDE(TestForANSIForScope)
  • CMakeDependentOption：巨集，用於提供相依於其他選項的選項。

    只有在一組其他條件為 true 時，此巨集才會向使用者顯示一個選項。當該選項未顯示時，會使用預設值，但是使用者設定的任何值都會被保留，以便在再次顯示該選項時使用。範例調用

      CMAKE_DEPENDENT_OPTION(USE_FOO "Use Foo" ON
                             "USE_BAR;NOT USE_ZOT" OFF)

    如果 USE_BAR 為 true 且 USE_ZOT 為 false，則會提供一個名為 USE_FOO 的選項，預設值為 ON。否則，將 USE_FOO 設為 OFF。如果 USE_BAR 或 USE_ZOT 的狀態發生變化，則會儲存 USE_FOO 選項的任何值，以便在重新啟用該選項時保留其舊值。

  • CMakeDetermineASM-ATTCompiler:

    使用 AT&T 語法 (例如 GNU as) 確定要用於 ASM 的編譯器

  • CMakeDetermineASMCompiler:

    確定要用於 ASM 程式的編譯器

  • CMakeDetermineASM_MASMCompiler:

    尋找 MS 組譯器 (masm 或 masm64)

  • CMakeExportBuildSettings：從專案匯出建置設定。
      CMAKE_EXPORT_BUILD_SETTINGS(SETTINGS_FILE)

    巨集定義，用於匯出建置設定以供其他專案使用。

      SETTINGS_FILE - the file into which the settings are to be stored.
  • CMakeFindFrameworks：輔助模組，用於尋找 OSX frameworks
  • CMakeForceCompiler:

    當 CMake 無法自動偵測編譯器識別資訊時，此模組會定義預期由交叉編譯工具鏈檔案使用的巨集。

    巨集 CMAKE_FORCE_C_COMPILER 具有以下簽名

       CMAKE_FORCE_C_COMPILER(<compiler> <compiler-id>)

    它將 CMAKE_C_COMPILER 設定為給定的編譯器，並將 cmake 內部變數 CMAKE_C_COMPILER_ID 設定為給定的編譯器 ID。它也會略過對正常運作的編譯器和基本編譯器資訊測試的檢查。

    巨集 CMAKE_FORCE_CXX_COMPILER 具有以下簽名

       CMAKE_FORCE_CXX_COMPILER(<compiler> <compiler-id>)

    它將 CMAKE_CXX_COMPILER 設定為給定的編譯器，並將 cmake 內部變數 CMAKE_CXX_COMPILER_ID 設定為給定的編譯器 ID。它也會略過對正常運作的編譯器和基本編譯器資訊測試的檢查。

    因此，一個簡單的工具鏈檔案可能如下所示

       INCLUDE (CMakeForceCompiler)
       SET(CMAKE_SYSTEM_NAME Generic)
       CMAKE_FORCE_C_COMPILER   (chc12 MetrowerksHicross)
       CMAKE_FORCE_CXX_COMPILER (chc12 MetrowerksHicross)
  • CMakeImportBuildSettings：從另一個專案匯入建置設定
      CMAKE_IMPORT_BUILD_SETTINGS(SETTINGS_FILE)

    巨集定義，用於從另一個專案匯入建置設定。SETTINGS_FILE 是由另一個專案呼叫 CMAKE_EXPORT_BUILD_SETTINGS 巨集所建立的檔案，請參閱 CMakeExportBuildSettings。

  • CMakeJavaInformation:

    這應該在 _INIT 變數用於初始化快取之前包含。由於規則變數具有 if 區塊，使用者仍然可以在這裡定義它們。但是，它仍然應該在平台檔案之後，以便可以對這些值進行更改。

  • CMakePrintSystemInformation：列印系統資訊

    此檔案可用於診斷目的，只需將其包含在專案中即可查看各種內部 CMake 變數。

  • CPack：建置二進制和原始碼套件安裝程式


    CPack 模組使用 `cpack` 程式產生各種格式的二進制和原始碼安裝程式。包含 CPack 模組會在產生的 makefile 中新增兩個新目標，`package` 和 `package_source`，它們分別建置二進制和原始碼安裝程式。產生的二進制安裝程式包含通過 CMake 的 INSTALL 命令 (以及已棄用的 INSTALL_FILES、INSTALL_PROGRAMS 和 INSTALL_TARGETS 命令) 安裝的所有內容。

    對於某些類型的二進制安裝程式 (包括 Mac OS X 和 Windows 上的圖形安裝程式)，CPack 會產生安裝程式，允許使用者選擇要安裝的個別應用程式元件。每個元件的內容由 CMake 的 INSTALL 命令的 COMPONENT 引數來識別。這些元件可以使用使用者友好的名稱和描述、元件間的相依性等進行註釋，並以各種方式分組以自訂產生的安裝程式。有關元件特定安裝的更多資訊，請參閱以下描述的 `cpack_add_*` 命令。

    在包含 CPack 模組之前，可以設定各種變數來自訂產生的安裝程式。最常用的變數是

       CPACK_PACKAGE_NAME - The name of the package (or application). If
       not specified, defaults to the project name.


       CPACK_PACKAGE_VENDOR - The name of the package vendor (e.g.,
       "Kitware").


       CPACK_PACKAGE_VERSION_MAJOR - Package major Version


       CPACK_PACKAGE_VERSION_MINOR - Package minor Version


       CPACK_PACKAGE_VERSION_PATCH - Package patch Version


       CPACK_PACKAGE_DESCRIPTION_FILE - A text file used to describe the
       project. Used, for example, the introduction screen of a
       CPack-generated Windows installer to describe the project.


       CPACK_PACKAGE_DESCRIPTION_SUMMARY - Short description of the
       project (only a few words).


       CPACK_PACKAGE_FILE_NAME - The name of the package file to generate,
       not including the extension. For example, cmake-2.6.1-Linux-i686.


       CPACK_PACKAGE_INSTALL_DIRECTORY - Installation directory on the
       target system, e.g., "CMake 2.5".


       CPACK_RESOURCE_FILE_LICENSE - License file for the project, which
       will typically be displayed to the user (often with an explicit
       "Accept" button, for graphical installers) prior to installation.


       CPACK_RESOURCE_FILE_README - ReadMe file for the project, which
       typically describes in some detail


       CPACK_RESOURCE_FILE_WELCOME - Welcome file for the project, which
       welcomes users to this installer. Typically used in the graphical
       installers on Windows and Mac OS X.


       CPACK_MONOLITHIC_INSTALL - Disables the component-based 
       installation mechanism, so that all components are always installed.


       CPACK_GENERATOR - List of CPack generators to use. If not
       specified, CPack will create a set of options (e.g.,
       CPACK_BINARY_NSIS) allowing the user to enable/disable individual
       generators.


       CPACK_OUTPUT_CONFIG_FILE - The name of the CPack configuration file
       for binary installers that will be generated by the CPack
       module. Defaults to CPackConfig.cmake.


       CPACK_PACKAGE_EXECUTABLES - Lists each of the executables along
       with a text label, to be used to create Start Menu shortcuts on
       Windows. For example, setting this to the list ccmake;CMake will
       create a shortcut named "CMake" that will execute the installed
       executable ccmake.


       CPACK_STRIP_FILES - List of files to be stripped. Starting with
       CMake 2.6.0 CPACK_STRIP_FILES will be a boolean variable which
       enables stripping of all files (a list of files evaluates to TRUE
       in CMake, so this change is compatible).


    以下 CPack 變數特定於原始碼套件，不會影響二進制套件

       CPACK_SOURCE_PACKAGE_FILE_NAME - The name of the source package,
       e.g., cmake-2.6.1


       CPACK_SOURCE_STRIP_FILES - List of files in the source tree that
       will be stripped. Starting with CMake 2.6.0
       CPACK_SOURCE_STRIP_FILES will be a boolean variable which enables
       stripping of all files (a list of files evaluates to TRUE in CMake,
       so this change is compatible).


       CPACK_SOURCE_GENERATOR - List of generators used for the source
       packages. As with CPACK_GENERATOR, if this is not specified then
       CPack will create a set of options (e.g., CPACK_SOURCE_ZIP)
       allowing users to select which packages will be generated.


       CPACK_SOURCE_OUTPUT_CONFIG_FILE - The name of the CPack
       configuration file for source installers that will be generated by
       the CPack module. Defaults to CPackSourceConfig.cmake.


       CPACK_SOURCE_IGNORE_FILES - Pattern of files in the source tree
       that won't be packaged when building a source package. This is a
       list of patterns, e.g., /CVS/;/\\.svn/;\\.swp$;\\.#;/#;.*~;cscope.*


    以下變數特定於使用 Nullsoft Installation System 在 Windows 上建置的圖形安裝程式。

       CPACK_PACKAGE_INSTALL_REGISTRY_KEY - Registry key used when
       installing this project.


       CPACK_NSIS_MUI_ICON - The icon file (.ico) for the generated
       install program.


       CPACK_NSIS_MUI_UNIICON - The icon file (.ico) for the generated
       uninstall program.


       CPACK_PACKAGE_ICON - A branding image that will be displayed inside
       the installer.


       CPACK_NSIS_EXTRA_INSTALL_COMMANDS - Extra NSIS commands that will
       be added to the install Section.


       CPACK_NSIS_EXTRA_UNINSTALL_COMMANDS - Extra NSIS commands that will
       be added to the uninstall Section.


       CPACK_NSIS_COMPRESSOR - The arguments that will be passed to the
       NSIS SetCompressor command.


       CPACK_NSIS_MODIFY_PATH - If this is set to "ON", then an extra page
       will appear in the installer that will allow the user to choose
       whether the program directory should be added to the system PATH
       variable.


       CPACK_NSIS_DISPLAY_NAME - The title displayed at the top of the
       installer.


       CPACK_NSIS_INSTALLED_ICON_NAME - A path to the executable that
       contains the installer icon.


       CPACK_NSIS_HELP_LINK - URL to a web site providing assistance in
       installing your application.


       CPACK_NSIS_URL_INFO_ABOUT - URL to a web site providing more
       information about your application.


       CPACK_NSIS_CONTACT - Contact information for questions and comments
       about the installation process.


       CPACK_NSIS_CREATE_ICONS_EXTRA - Additional NSIS commands for
       creating start menu shortcuts.


       CPACK_NSIS_DELETE_ICONS_EXTRA -Additional NSIS commands to
       uninstall start menu shortcuts.


    以下變數特定於使用 PackageMaker 在 Mac OS X 上建置的安裝程式

       CPACK_OSX_PACKAGE_VERSION - The version of Mac OS X that the
       resulting PackageMaker archive should be compatible
       with. Different versions of Mac OS X support different
       features. For example, CPack can only build component-based
       installers for Mac OS X 10.4 or newer, and can only build
       installers that download component son-the-fly for Mac OS X 10.5
       or newer. If left blank, this value will be set to the minimum
       version of Mac OS X that supports the requested features. Set this
       variable to some value (e.g., 10.4) only if you want to guarantee
       that your installer will work on that version of Mac OS X, and
       don't mind missing extra features available in the installer
       shipping with later versions of Mac OS X.


    以下變數用於 CPack 的進階用途

       CPACK_CMAKE_GENERATOR - What CMake generator should be used if the
       project is CMake project. Defaults to the value of CMAKE_GENERATOR;
       few users will want to change this setting.


       CPACK_INSTALL_CMAKE_PROJECTS - List of four values that specify
       what project to install. The four values are: Build directory,
       Project Name, Project Component, Directory. If omitted, CPack will
       build an installer that installers everything.


       CPACK_SYSTEM_NAME - System name, defaults to the value of
       ${CMAKE_SYSTEM_NAME}.


       CPACK_PACKAGE_VERSION - Package full version, used internally. By
       default, this is built from CPACK_PACKAGE_VERSION_MAJOR,
       CPACK_PACKAGE_VERSION_MINOR, and CPACK_PACKAGE_VERSION_PATCH.


       CPACK_TOPLEVEL_TAG - Directory for the installed files.


       CPACK_INSTALL_COMMANDS - Extra commands to install components.


       CPACK_INSTALL_DIRECTORIES - Extra directories to install.


    元件特定的安裝允許使用者在安裝過程中選擇要安裝的特定元件集。安裝元件由 CMake 的 INSTALL 命令的 COMPONENT 引數識別，並且應由以下 CPack 命令進一步描述

       cpack_add_component - Describes a CPack installation component
       named by the COMPONENT argument to a CMake INSTALL command.


         cpack_add_component(compname
                             [DISPLAY_NAME name]
                             [DESCRIPTION description]
                             [HIDDEN | REQUIRED | DISABLED ]
                             [GROUP group]
                             [DEPENDS comp1 comp2 ... ]
                             [INSTALL_TYPES type1 type2 ... ]
                             [DOWNLOADED]
                             [ARCHIVE_FILE filename])


       The cmake_add_component command describes an installation
       component, which the user can opt to install or remove as part of
       the graphical installation process. compname is the name of the
       component, as provided to the COMPONENT argument of one or more
       CMake INSTALL commands.


       DISPLAY_NAME is the displayed name of the component, used in
       graphical installers to display the component name. This value can
       be any string.


       DESCRIPTION is an extended description of the component, used in
       graphical installers to give the user additional information about
       the component. Descriptions can span multiple lines using "\n" as
       the line separator. Typically, these descriptions should be no
       more than a few lines long.


       HIDDEN indicates that this component will be hidden in the
       graphical installer, so that the user cannot directly change
       whether it is installed or not.


       REQUIRED indicates that this component is required, and therefore
       will always be installed. It will be visible in the graphical
       installer, but it cannot be unselected. (Typically, required
       components are shown greyed out).


       DISABLED indicates that this component should be disabled
       (unselected) by default. The user is free to select this component
       for installation, unless it is also HIDDEN.


       DEPENDS lists the components on which this component depends. If
       this component is selected, then each of the components listed
       must also be selected. The dependency information is encoded
       within the installer itself, so that users cannot install
       inconsitent sets of components.


       GROUP names the component group of which this component is a
       part. If not provided, the component will be a standalone
       component, not part of any component group. Component groups are
       described with the cpack_add_component_group command, detailed
       below.


       INSTALL_TYPES lists the installation types of which this component
       is a part. When one of these installations types is selected, this
       component will automatically be selected. Installation types are
       described with the cpack_add_install_type command, detailed below.


       DOWNLOADED indicates that this component should be downloaded
       on-the-fly by the installer, rather than packaged in with the
       installer itself. For more information, see the cpack_configure_downloads
       command.


       ARCHIVE_FILE provides a name for the archive file created by CPack
       to be used for downloaded components. If not supplied, CPack will
       create a file with some name based on CPACK_PACKAGE_FILE_NAME and
       the name of the component. See cpack_configure_downloads for more
       information.


       cpack_add_component_group - Describes a group of related CPack
       installation components.


         cpack_add_component_group(groupname
                                  [DISPLAY_NAME name]
                                  [DESCRIPTION description]
                                  [PARENT_GROUP parent]
                                  [EXPANDED]
                                  [BOLD_TITLE])


       The cpack_add_component_group describes a group of installation
       components, which will be placed together within the listing of
       options. Typically, component groups allow the user to
       select/deselect all of the components within a single group via a
       single group-level option. Use component groups to reduce the
       complexity of installers with many options. groupname is an
       arbitrary name used to identify the group in the GROUP argument of
       the cpack_add_component command, which is used to place a
       component in a group. The name of the group must not conflict with
       the name of any component.


       DISPLAY_NAME is the displayed name of the component group, used in
       graphical installers to display the component group name. This
       value can be any string.


       DESCRIPTION is an extended description of the component group,
       used in graphical installers to give the user additional
       information about the components within that group. Descriptions
       can span multiple lines using "\n" as the line
       separator. Typically, these descriptions should be no more than a
       few lines long.


       PARENT_GROUP, if supplied, names the parent group of this group. 
       Parent groups are used to establish a hierarchy of groups, 
       providing an arbitrary hierarchy of groups.


       EXPANDED indicates that, by default, the group should show up as
       "expanded", so that the user immediately sees all of the
       components within the group. Otherwise, the group will initially
       show up as a single entry.


       BOLD_TITLE indicates that the group title should appear in bold,
       to call the user's attention to the group.


       cpack_add_install_type - Add a new installation type containing a
       set of predefined component selections to the graphical installer.
                          
         cpack_add_install_type(typename
                                [DISPLAY_NAME name])   


       The cpack_add_install_type command identifies a set of preselected
       components that represents a common use case for an
       application. For example, a "Developer" install type might include
       an application along with its header and library files, while an
       "End user" install type might just include the application's
       executable. Each component identifies itself with one or more
       install types via the INSTALL_TYPES argument to
       cpack_add_component.


       DISPLAY_NAME is the displayed name of the install type, which will
       typically show up in a drop-down box within a graphical
       installer. This value can be any string.


       cpack_configure_downloads - Configure CPack to download selected
       components on-the-fly as part of the installation process.


         cpack_configure_downloads(site
                                   [UPLOAD_DIRECTORY dirname]
                                   [ALL]
                                   [ADD_REMOVE|NO_ADD_REMOVE])


       The cpack_configure_downloads command configures installation-time
       downloads of selected components. For each downloadable component,
       CPack will create an archive containing the contents of that
       component, which should be uploaded to the given site. When the
       user selects that component for installation, the installer will
       download and extract the component in place. This feature is
       useful for creating small installers that only download the
       requested components, saving bandwidth. Additionally, the
       installers are small enough that they will be installed as part of
       the normal installation process, and the "Change" button in
       Windows Add/Remove Programs control panel will allow one to add or
       remove parts of the application after the original
       installation. On Windows, the downloaded-components functionality
       requires the ZipDLL plug-in for NSIS, available at:


         http://nsis.sourceforge.net/ZipDLL_plug-in


       On Mac OS X, installers that download components on-the-fly can
       only be built and installed on system using Mac OS X 10.5 or
       later.


       The site argument is a URL where the archives for downloadable 
       components will reside, e.g., http://www.cmake.org/files/2.6.1/installer/
       All of the archives produced by CPack should be uploaded to that location.


       UPLOAD_DIRECTORY is the local directory where CPack will create the 
       various archives for each of the components. The contents of this
       directory should be uploaded to a location accessible by the URL given
       in the site argument. If omitted, CPack will use the directory CPackUploads
       inside the CMake binary directory to store the generated archives.


       The ALL flag indicates that all components be downloaded. Otherwise, only 
       those components explicitly marked as DOWNLOADED or that have a specified 
       ARCHIVE_FILE will be downloaded. Additionally, the ALL option implies
       ADD_REMOVE (unless NO_ADD_REMOVE is specified).


       ADD_REMOVE indicates that CPack should install a copy of the installer
       that can be called from Windows' Add/Remove Programs dialog (via the 
       "Modify" button) to change the set of installed components. NO_ADD_REMOVE
       turns off this behavior. This option is ignored on Mac OS X.
  • CPackRPM:

    用於建立 RPM 套件的 CPack 腳本 作者：Eric Noulard，並得到 Alexander Neundorf 的幫助。CPackRPM 使用的所有變數都以 CPACK_RPM_ 前綴開頭

    以下是使用的變數列表

  • CTest：使用 CTest/CDash 設定專案以進行測試

    此檔案會設定專案以使用 CTest/CDash/Dart 測試/儀表板流程。此模組應包含在專案頂部的 CMakeLists.txt 檔案中。典型用法

      INCLUDE(CTest)
      IF(BUILD_TESTING)
        # ... testing related CMake code ...
      ENDIF(BUILD_TESTING)

    CTest 模組會建立 BUILD_TESTING 選項，以判斷是否應啟用測試支援。預設值為 ON。

  • CheckCCompilerFlag：檢查 C 編譯器是否支援給定的旗標。

    CHECK_C_COMPILER_FLAG(FLAG VARIABLE)

      FLAG - the compiler flag
      VARIABLE - variable to store the result


      This actually calls the check_c_source_compiles macro.
      See help for CheckCSourceCompiles for a listing of variables
      that can modify the build.
  • CheckCSourceCompiles：檢查原始碼是否編譯的巨集

    CHECK_C_SOURCE_COMPILES(SOURCE VAR)

      SOURCE   - source code to try to compile
      VAR      - variable to store whether the source code compiled


    在呼叫此巨集之前，可以設定以下變數來修改檢查的執行方式

      CMAKE_REQUIRED_FLAGS = string of compile command line flags
      CMAKE_REQUIRED_DEFINITIONS = list of macros to define (-DFOO=bar)
      CMAKE_REQUIRED_INCLUDES = list of include directories
      CMAKE_REQUIRED_LIBRARIES = list of libraries to link
  • CheckCSourceRuns：檢查原始碼是否可執行的巨集

    CHECK_C_SOURCE_RUNS(原始碼 變數)

      SOURCE   - source code to try to compile
      VAR      - variable to store the result, 1 for success, empty for failure


    在呼叫此巨集之前，可以設定以下變數來修改檢查的執行方式

      CMAKE_REQUIRED_FLAGS = string of compile command line flags
      CMAKE_REQUIRED_DEFINITIONS = list of macros to define (-DFOO=bar)
      CMAKE_REQUIRED_INCLUDES = list of include directories
      CMAKE_REQUIRED_LIBRARIES = list of libraries to link
  • CheckCXXCompilerFlag：檢查 CXX 編譯器是否支援給定的標誌。

    CHECK_CXX_COMPILER_FLAG(標誌 變數)

      FLAG - the compiler flag
      VARIABLE - variable to store the result
  • CheckCXXSourceCompiles：檢查原始碼是否可編譯的巨集

    CHECK_CXX_SOURCE_COMPILES(原始碼 變數)

      SOURCE - source code to try to compile
      VAR    - variable to store whether the source code compiled


    在呼叫此巨集之前，可以設定以下變數來修改檢查的執行方式

      CMAKE_REQUIRED_FLAGS = string of compile command line flags
      CMAKE_REQUIRED_DEFINITIONS = list of macros to define (-DFOO=bar)
      CMAKE_REQUIRED_INCLUDES = list of include directories
      CMAKE_REQUIRED_LIBRARIES = list of libraries to link
  • CheckCXXSourceRuns：檢查原始碼是否可編譯的巨集

    CHECK_CXX_SOURCE_RUNS(原始碼 變數)

      SOURCE - source code to try to compile
      VAR    - variable to store the result, 1 for success, empty for failure


    在呼叫此巨集之前，可以設定以下變數來修改檢查的執行方式

      CMAKE_REQUIRED_FLAGS = string of compile command line flags
      CMAKE_REQUIRED_DEFINITIONS = list of macros to define (-DFOO=bar)
      CMAKE_REQUIRED_INCLUDES = list of include directories
      CMAKE_REQUIRED_LIBRARIES = list of libraries to link
  • CheckFortranFunctionExists：檢查 Fortran 函式是否存在的巨集

    CHECK_FORTRAN_FUNCTION_EXISTS(函式 變數)

      FUNCTION - the name of the Fortran function
      VARIABLE - variable to store the result


    在呼叫此巨集之前，可以設定以下變數來修改檢查的執行方式

      CMAKE_REQUIRED_LIBRARIES = list of libraries to link
  • CheckFunctionExists：檢查函式是否存在的巨集

    CHECK_FUNCTION_EXISTS(函式 變數)

      FUNCTION - the name of the function
      VARIABLE - variable to store the result


    在呼叫此巨集之前，可以設定以下變數來修改檢查的執行方式

      CMAKE_REQUIRED_FLAGS = string of compile command line flags
      CMAKE_REQUIRED_DEFINITIONS = list of macros to define (-DFOO=bar)
      CMAKE_REQUIRED_INCLUDES = list of include directories
      CMAKE_REQUIRED_LIBRARIES = list of libraries to link
  • CheckIncludeFile：檢查 include 檔案是否存在的巨集。

    CHECK_INCLUDE_FILE(include 變數)

      INCLUDE  - name of include file
      VARIABLE - variable to return result

    第三個可選參數是添加到編譯行的 CFlags，或者您可以使用 CMAKE_REQUIRED_FLAGS

    在呼叫此巨集之前，可以設定以下變數來修改檢查的執行方式

      CMAKE_REQUIRED_FLAGS = string of compile command line flags
      CMAKE_REQUIRED_DEFINITIONS = list of macros to define (-DFOO=bar)
      CMAKE_REQUIRED_INCLUDES = list of include directories


  • CheckIncludeFileCXX：檢查 include 檔案是否存在。
      CHECK_INCLUDE_FILE_CXX(INCLUDE VARIABLE)


      INCLUDE  - name of include file
      VARIABLE - variable to return result

    第三個可選參數是添加到編譯行的 CFlags，或者您可以使用 CMAKE_REQUIRED_FLAGS。

    在呼叫此巨集之前，可以設定以下變數來修改檢查的執行方式

      CMAKE_REQUIRED_FLAGS = string of compile command line flags
      CMAKE_REQUIRED_DEFINITIONS = list of macros to define (-DFOO=bar)
      CMAKE_REQUIRED_INCLUDES = list of include directories


  • CheckIncludeFiles：檢查檔案是否可以被 include


    CHECK_INCLUDE_FILES(include 變數)

      INCLUDE  - list of files to include
      VARIABLE - variable to return result


    在呼叫此巨集之前，可以設定以下變數來修改檢查的執行方式

      CMAKE_REQUIRED_FLAGS = string of compile command line flags
      CMAKE_REQUIRED_DEFINITIONS = list of macros to define (-DFOO=bar)
      CMAKE_REQUIRED_INCLUDES = list of include directories
  • CheckLibraryExists：檢查函式是否存在。

    CHECK_LIBRARY_EXISTS (函式庫 函式 位置 變數)

      LIBRARY  - the name of the library you are looking for
      FUNCTION - the name of the function
      LOCATION - location where the library should be found
      VARIABLE - variable to store the result


    在呼叫此巨集之前，可以設定以下變數來修改檢查的執行方式

      CMAKE_REQUIRED_FLAGS = string of compile command line flags
      CMAKE_REQUIRED_DEFINITIONS = list of macros to define (-DFOO=bar)
      CMAKE_REQUIRED_LIBRARIES = list of libraries to link
  • CheckStructHasMember：檢查給定的結構或類別是否具有指定的成員變數

    CHECK_STRUCT_HAS_MEMBER (結構 成員 標頭 變數)

      STRUCT - the name of the struct or class you are interested in
      MEMBER - the member which existence you want to check
      HEADER - the header(s) where the prototype should be declared
      VARIABLE - variable to store the result


    在呼叫此巨集之前，可以設定以下變數來修改檢查的執行方式

      CMAKE_REQUIRED_FLAGS = string of compile command line flags
      CMAKE_REQUIRED_DEFINITIONS = list of macros to define (-DFOO=bar)
      CMAKE_REQUIRED_INCLUDES = list of include directories


    範例：CHECK_STRUCT_HAS_MEMBER("struct timeval" tv_sec sys/select.h HAVE_TIMEVAL_TV_SEC)

  • CheckSymbolExists：檢查符號是否存在於 include 檔案中

    CHECK_SYMBOL_EXISTS(符號 檔案 變數)

      SYMBOL   - symbol
      FILES    - include files to check
      VARIABLE - variable to return result


    在呼叫此巨集之前，可以設定以下變數來修改檢查的執行方式

      CMAKE_REQUIRED_FLAGS = string of compile command line flags
      CMAKE_REQUIRED_DEFINITIONS = list of macros to define (-DFOO=bar)
      CMAKE_REQUIRED_INCLUDES = list of include directories
      CMAKE_REQUIRED_LIBRARIES = list of libraries to link
  • CheckTypeSize：檢查類型的大小
      CHECK_TYPE_SIZE(TYPE VARIABLE [BUILTIN_TYPES_ONLY])

    檢查類型是否存在並判斷類型的大小。如果類型存在，則大小將儲存到變數中。這也會呼叫 check_include_file 來檢查 sys/types.h、stdint.h 和 stddef.h，並設定 HAVE_SYS_TYPES_H、HAVE_STDINT_H 和 HAVE_STDDEF_H。這是因為許多類型都儲存在這些 include 檔案中。

      VARIABLE - variable to store size if the type exists.
      HAVE_${VARIABLE} - does the variable exists or not
      BUILTIN_TYPES_ONLY - The third argument is optional and if 
                           it is set to the string BUILTIN_TYPES_ONLY
                           this macro will not check for any header files.

    在呼叫此巨集之前，可以設定以下變數來修改檢查的執行方式

      CMAKE_REQUIRED_FLAGS = string of compile command line flags
      CMAKE_REQUIRED_DEFINITIONS = list of macros to define (-DFOO=bar)
      CMAKE_REQUIRED_INCLUDES = list of include directories
      CMAKE_REQUIRED_LIBRARIES = list of libraries to link
  • CheckVariableExists：檢查變數是否存在。
      CHECK_VARIABLE_EXISTS(VAR VARIABLE)
      
      VAR      - the name of the variable
      VARIABLE - variable to store the result


    此巨集僅適用於 C 變數。

    在呼叫此巨集之前，可以設定以下變數來修改檢查的執行方式

      CMAKE_REQUIRED_FLAGS = string of compile command line flags
      CMAKE_REQUIRED_DEFINITIONS = list of macros to define (-DFOO=bar)
      CMAKE_REQUIRED_LIBRARIES = list of libraries to link
  • Dart：設定專案以使用 CTest 或舊的 Dart Tcl Client 進行測試

    此檔案是 CTest 模組的向後相容版本。它支援使用舊的 Dart 1 Tcl client 來驅動儀表板提交，以及使用 CTest 進行測試。此模組應包含在專案頂部的 CMakeLists.txt 檔案中。典型用法

      INCLUDE(Dart)
      IF(BUILD_TESTING)
        # ... testing related CMake code ...
      ENDIF(BUILD_TESTING)

    BUILD_TESTING 選項由 Dart 模組建立，以判斷是否應啟用測試支援。預設值為 ON。

  • Documentation：DocumentationVTK.cmake

    此檔案提供對 VTK 文件框架的支援。它依賴於多種工具（Doxygen、Perl 等）。

  • FeatureSummary：用於產生已啟用/停用功能摘要的巨集


    PRINT_ENABLED_FEATURES()

       Print a summary of all enabled features. By default all successfull
       FIND_PACKAGE() calls will appear here, except the ones which used the QUIET keyword.
       Additional features can be added by appending an entry to the global ENABLED_FEATURES
       property. If SET_FEATURE_INFO() is used for that feature, the output will be much 
       more informative.


    PRINT_DISABLED_FEATURES()

       Same as PRINT_ENABLED_FEATURES(), but for disabled features. It can be extended
       the same way by adding to the global property DISABLED_FEATURES.


    SET_FEATURE_INFO(名稱 描述 [URL [註解] ] )

        Use this macro to set up information about the named feature, which will
        then be displayed by PRINT_ENABLED/DISABLED_FEATURES().
        Example: SET_FEATURE_INFO(LibXml2 "XML processing library." "http://xmlsoft.org/")


  • FindASPELL：嘗試尋找 ASPELL

    完成後，這將定義

      ASPELL_FOUND - system has ASPELL
      ASPELL_INCLUDE_DIR - the ASPELL include directory
      ASPELL_LIBRARIES - The libraries needed to use ASPELL
      ASPELL_DEFINITIONS - Compiler switches required for using ASPELL
  • FindAVIFile：尋找 AVIFILE 函式庫和 include 路徑

    AVIFILE（http://avifile.sourceforge.net/）是一組用於 i386 機器以使用各種 AVI 編碼器的函式庫。除了 Linux 之外的支援有限。Windows 提供原生 AVI 支援，因此不需要此函式庫。此模組定義

      AVIFILE_INCLUDE_DIR, where to find avifile.h , etc.
      AVIFILE_LIBRARIES, the libraries to link against
      AVIFILE_DEFINITIONS, definitions to use when compiling
      AVIFILE_FOUND, If false, don't try to use AVIFILE
  • FindBLAS：尋找 BLAS 函式庫

    此模組尋找已安裝的 Fortran 函式庫，該函式庫實作 BLAS 線性代數介面（請參閱 http://www.netlib.org/blas/）。搜尋的函式庫清單取自 autoconf 巨集檔案 acx_blas.m4（分發於 http://ac-archive.sourceforge.net/ac-archive/acx_blas.html）。

    此模組設定以下變數

      BLAS_FOUND - set to true if a library implementing the BLAS interface
        is found
      BLAS_LINKER_FLAGS - uncached list of required linker flags (excluding -l
        and -L).
      BLAS_LIBRARIES - uncached list of libraries (using full path name) to
        link against to use BLAS
      BLAS95_LIBRARIES - uncached list of libraries (using full path name)
        to link against to use BLAS95 interface
      BLAS95_FOUND - set to true if a library implementing the BLAS f95 interface
        is found
      BLA_STATIC  if set on this determines what kind of linkage we do (static)
      BLA_VENDOR  if set checks only the specified vendor, if not set checks
         all the posibilities
      BLA_F95     if set on tries to find the f95 interfaces for BLAS/LAPACK

    ######### ## 此模組中有效的供應商清單 (BLA_VENDOR) # ATLAS、PhiPACK、CXML、DXML、SunPerf、SCSL、SGIMATH、IBMESSL、Intel10_32 (intel mkl v10 32 位元)、Intel10_64lp (intel mkl v10 64 位元，lp 線程模型，lp64 模型)、# Intel (較舊版本的 mkl 32 位元和 64 位元)、ACML、Apple、NAS、應啟用通用 C/CXX 以使用 Intel mkl

  • FindBZip2：嘗試尋找 BZip2

    完成後，這將定義

      BZIP2_FOUND - system has BZip2
      BZIP2_INCLUDE_DIR - the BZip2 include directory
      BZIP2_LIBRARIES - Link these to use BZip2
      BZIP2_DEFINITIONS - Compiler switches required for using BZip2
      BZIP2_NEED_PREFIX - this is set if the functions are prefixed with BZ2_
  • FindBoost：嘗試尋找 Boost include 目錄和函式庫

    此模組的使用方式如下

    == 使用來自 Boost 內的僅標頭函式庫：==

       find_package( Boost 1.36.0 )
       if(Boost_FOUND)
          include_directories(${Boost_INCLUDE_DIRS})
          add_executable(foo foo.cc)
       endif()



    == 使用來自 Boost 內的實際函式庫：==

       set(Boost_USE_STATIC_LIBS   ON)
       set(Boost_USE_MULTITHREADED ON)
       find_package( Boost 1.36.0 COMPONENTS date_time filesystem system ... )


       if(Boost_FOUND)
          include_directories(${Boost_INCLUDE_DIRS})
          add_executable(foo foo.cc)
          target_link_libraries(foo ${Boost_LIBRARIES})
       endif()



    組件清單只需要包含 boost 函式庫的實際名稱，例如「date_time」代表「libboost_date_time」。如果您使用的 Boost 部分僅包含標頭檔案（例如 foreach），則不需要指定 COMPONENTS。

    您應該提供應使用的最小版本號。如果您提供此版本號並指定 REQUIRED 屬性，則如果找不到指定的或更高版本，此模組將會失敗。如果您指定版本號，則會自動將其放入考慮的版本號清單中，因此不需要在 Boost_ADDITIONAL_VERSIONS 變數中指定（請參閱下文）。

    Visual Studio 使用者注意事項

         Automatic linking is used on MSVC & Borland compilers by default when
         #including things in Boost.  It's important to note that setting
         Boost_USE_STATIC_LIBS to OFF is NOT enough to get you dynamic linking,
         should you need this feature.  Automatic linking typically uses static
         libraries with a few exceptions (Boost.Python is one).


         Please see the section below near Boost_LIB_DIAGNOSTIC_DEFINITIONS for
         more details.  Adding a TARGET_LINK_LIBRARIES() as shown in the example
         above appears to cause VS to link dynamically if Boost_USE_STATIC_LIBS
         gets set to OFF.  It is suggested you avoid automatic linking since it
         will make your application less portable.


    =========== Boost_ADDITIONAL_VERSIONS 的混亂之處（抱歉？）===========

    好的，因此 Boost_ADDITIONAL_VERSIONS 變數可用於指定在搜尋 Boost 時應考慮的 boost 版本號清單。不幸的是，boost 將版本號放入函式庫的實際檔案名稱中，因此將來發布新的 Boost 版本時，肯定需要此變數。

    目前，此模組搜尋以下版本號：1.33、1.33.0、1.33.1、1.34、1.34.0、1.34.1、1.35、1.35.0、1.35.1、1.36、1.36.0、1.36.1、1.37、1.37.0、1.38、1.38.0

    注意：如果您在 Boost_ADDITIONAL_VERSIONS 中新增新的主要 1.x 版本，則應同時新增 1.x 和 1.x.0，如上所示。如果第 3 個版本號為 0，則官方 Boost include 目錄會從 include 路徑中省略第 3 個版本號，但並非所有二進位 Boost 版本都如此。

    SET(Boost_ADDITIONAL_VERSIONS "0.99" "0.99.0" "1.78" "1.78.0")

    ============================================================================

    此模組使用的變數，它們可以更改預設行為，並且需要在呼叫 find_package 之前設定

      Boost_USE_MULTITHREADED       Can be set to OFF to use the non-multithreaded
                                    boost libraries.  If not specified, defaults
                                    to ON.


      Boost_USE_STATIC_LIBS         Can be set to ON to force the use of the static
                                    boost libraries. Defaults to OFF.


    此模組使用的其他變數，您可能想要設定它們。

      Boost_ADDITIONAL_VERSIONS     A list of version numbers to use for searching
                                    the boost include directory.  Please see
                                    the documentation above regarding this
                                    annoying, but necessary variable :(


      Boost_DEBUG                   Set this to TRUE to enable debugging output
                                    of FindBoost.cmake if you are having problems.
                                    Please enable this before filing any bug
                                    reports.


      Boost_COMPILER                Set this to the compiler suffix used by Boost
                                    (e.g. "-gcc43") if FindBoods has problems finding
                                    the proper Boost installation


      These last three variables are available also as environment variables:


      BOOST_ROOT or BOOSTROOT       The preferred installation prefix for searching for
                                    Boost.  Set this if the module has problems finding
                                    the proper Boost installation.


      BOOST_INCLUDEDIR              Set this to the include directory of Boost, if the
                                    module has problems finding the proper Boost installation


      BOOST_LIBRARYDIR              Set this to the lib directory of Boost, if the
                                    module has problems finding the proper Boost installation


    此模組定義的變數

      Boost_FOUND                          System has Boost, this means the include dir was
                                           found, as well as all the libraries specified in
                                           the COMPONENTS list.


      Boost_INCLUDE_DIRS                   Boost include directories: not cached


      Boost_INCLUDE_DIR                    This is almost the same as above, but this one is
                                           cached and may be modified by advanced users


      Boost_LIBRARIES                      Link these to use the Boost libraries that you
                                           specified: not cached


      Boost_LIBRARY_DIRS                   The path to where the Boost library files are.


      Boost_VERSION                        The version number of the boost libraries that
                                           have been found, same as in version.hpp from Boost


      Boost_LIB_VERSION                    The version number in filename form as
                                           it's appended to the library filenames


      Boost_MAJOR_VERSION                  major version number of boost
      Boost_MINOR_VERSION                  minor version number of boost
      Boost_SUBMINOR_VERSION               subminor version number of boost


      Boost_LIB_DIAGNOSTIC_DEFINITIONS     [WIN32 Only] You can call
                                           add_definitions(${Boost_LIB_DIAGNOSTIC_DEFINTIIONS})
                                           to have diagnostic information about Boost's
                                           automatic linking outputted during compilation time.


    對於您列出的每個組件，都會設定以下變數。注意：組件名稱需要小寫，就像 boost 函式庫名稱一樣，但是 CMake 變數對於組件部分使用大寫。因此，您會得到例如 Boost_SERIALIZATION_FOUND。

      Boost_${COMPONENT}_FOUND             True IF the Boost library "component" was found.
      Boost_${COMPONENT}_LIBRARY           The absolute path of the Boost library "component".
      Boost_${COMPONENT}_LIBRARY_DEBUG     The absolute path of the debug version of the
                                           Boost library "component".
      Boost_${COMPONENT}_LIBRARY_RELEASE   The absolute path of the release version of the
                                           Boost library "component"


      Copyright (c) 2006-2008 Andreas Schneider <mail@cynapses.org>
      Copyright (c) 2007      Wengo
      Copyright (c) 2007      Mike Jackson
      Copyright (c) 2008      Andreas Pakulat <apaku@gmx.de>


      Redistribution AND use is allowed according to the terms of the New
      BSD license.
      For details see the accompanying COPYING-CMAKE-SCRIPTS file.


  • FindCABLE：尋找 CABLE

    此模組會尋找是否已安裝 CABLE，並確定 include 檔案和函式庫的位置。此程式碼會設定以下變數

      CABLE             the path to the cable executable
      CABLE_TCL_LIBRARY the path to the Tcl wrapper library
      CABLE_INCLUDE_DIR the path to the include directory


    若要建置 Tcl 包裝函式，您應該新增共用函式庫並將其連結到 ${CABLE_TCL_LIBRARY}。您還應該新增 ${CABLE_INCLUDE_DIR} 作為 include 目錄。

  • FindCURL：尋找 curl

    尋找原生 CURL 標頭和函式庫。

      CURL_INCLUDE_DIRS - where to find curl/curl.h, etc.
      CURL_LIBRARIES    - List of libraries when using curl.
      CURL_FOUND        - True if curl found.
  • FindCVS:

    該模組定義了以下變數

       CVS_EXECUTABLE - path to cvs command line client
       CVS_FOUND - true if the command line client was found

    使用範例

       find_package(CVS)
       if(CVS_FOUND)
         message("CVS found: ${CVS_EXECUTABLE}")
       endif(CVS_FOUND)
  • FindCoin3D：尋找 Coin3D (Open Inventor)

    Coin3D 是 Open Inventor API 的實作。它為 3D 可視化提供資料結構和演算法 http://www.coin3d.org/

    此模組定義了以下變數

      COIN3D_FOUND         - system has Coin3D - Open Inventor
      COIN3D_INCLUDE_DIRS  - where the Inventor include directory can be found
      COIN3D_LIBRARIES     - Link to this to use Coin3D


  • FindCups：嘗試尋找 Cups 列印系統

    完成後，這將定義

      CUPS_FOUND - system has Cups
      CUPS_INCLUDE_DIR - the Cups include directory
      CUPS_LIBRARIES - Libraries needed to use Cups
      Set CUPS_REQUIRE_IPP_DELETE_ATTRIBUTE to TRUE if you need a version which 
      features this function (i.e. at least 1.1.19)
  • FindCurses：尋找 curses include 檔案和函式庫


      CURSES_FOUND - system has Curses
      CURSES_INCLUDE_DIR - the Curses include directory
      CURSES_LIBRARIES - The libraries needed to use Curses
      CURSES_HAVE_CURSES_H - true if curses.h is available
      CURSES_HAVE_NCURSES_H - true if ncurses.h is available
      CURSES_HAVE_NCURSES_NCURSES_H - true if ncurses/ncurses.h is available
      CURSES_HAVE_NCURSES_CURSES_H - true if ncurses/curses.h is available
      CURSES_LIBRARY - set for backwards compatibility with 2.4 CMake


    如果需要 NCurses 功能，請在 FIND_PACKAGE() 命令之前將 CURSES_NEED_NCURSES 設定為 TRUE。

  • FindCxxTest：尋找 CxxTest

    尋找 CxxTest 套件，並宣告一個協助程式巨集，用於建立單元測試並將其與 CTest 整合。有關 CxxTest 的更多詳細資訊，請參閱 http://cxxtest.tigris.org

    輸入變數

       CXXTEST_USE_PYTHON
           If true, the CXXTEST_ADD_TEST macro will use
           the Python test generator instead of Perl.


    輸出變數

       CXXTEST_FOUND
           True if the CxxTest framework was found
       CXXTEST_INCLUDE_DIR
           Where to find the CxxTest include directory
       CXXTEST_PERL_TESTGEN_EXECUTABLE
           The perl-based test generator.
       CXXTEST_PYTHON_TESTGEN_EXECUTABLE
           The python-based test generator.


    供 CMake 使用者使用的巨集

        CXXTEST_ADD_TEST(<test_name> <gen_source_file> <input_files_to_testgen...>)
           Creates a CxxTest runner and adds it to the CTest testing suite
           Parameters:
               test_name               The name of the test
               gen_source_file         The generated source filename to be generated by CxxTest
               input_files_to_testgen  The list of header files containing the
                                       CxxTest::TestSuite's to be included in this runner
               
           #==============
           Example Usage:


               FIND_PACKAGE(CxxTest)
               INCLUDE_DIRECTORIES(${CXXTEST_INCLUDE_DIR})


               ENABLE_TESTING()
               CXXTEST_ADD_TEST(unittest_foo foo_test.cc ${CMAKE_CURRENT_SOURCE_DIR}/foo_test.h)


                  This will:
                  1. Invoke the testgen executable to autogenerate foo_test.cc in the
                     binary tree from "foo_test.h" in the current source directory.
                  2. Create an executable and test called unittest_foo.
                   
          #=============
          Example foo_test.h:


              #include <cxxtest/TestSuite.h>
              
              class MyTestSuite : public CxxTest::TestSuite 
              {
              public:
                 void testAddition( void )
                 {
                    TS_ASSERT( 1 + 1 > 1 );
                    TS_ASSERT_EQUALS( 1 + 1, 2 );
                 }
              };



    FindCxxTest.cmake 版權所有 (c) 2008

         Philip Lowman <philip@yhbt.com>


    版本 1.0 (1/8/08)

         Fixed CXXTEST_INCLUDE_DIRS so it will work properly
         Eliminated superfluous CXXTEST_FOUND assignment
         Cleaned up and added more documentation
  • FindCygwin：此模組尋找 Cygwin


  • FindDCMTK：尋找 DCMTK 函式庫


  • FindDart：尋找 DART

    此模組尋找 dart 測試軟體，並將 DART_ROOT 設定為指向找到的位置。

  • FindDevIL:

    此模組尋找開發人員的圖像函式庫。http://openil.sourceforge.net/

    此模組設定：IL_LIBRARY IL 函式庫的名稱。ILU_LIBRARY ILU 函式庫的名稱。ILUT_LIBRARY ILUT 函式庫的名稱。IL_INCLUDE_DIR 在哪裡找到 il.h、ilu.h 和 ilut.h 檔案。IL_FOUND 如果設定了以上所有變數，則設定為 TRUE。

  • FindDoxygen：此模組尋找 Doxygen 和 Graphviz 的 dot 路徑

    Doxygen 是一種文件產生工具。請參閱 https://doxygen.dev.org.tw

    此模組接受以下可選變數

       DOXYGEN_SKIP_DOT       = If true this module will skip trying to find Dot
                                (an optional component often used by Doxygen)


    此模組定義了以下變數

       DOXYGEN_EXECUTABLE     = The path to the doxygen command.
       DOXYGEN_FOUND          = Was Doxygen found or not?


       DOXYGEN_DOT_EXECUTABLE = The path to the dot program used by doxygen.
       DOXYGEN_DOT_FOUND      = Was Dot found or not?
       DOXYGEN_DOT_PATH       = The path to dot not including the executable



  • FindEXPAT：尋找 expat

    尋找原生 EXPAT 標頭和函式庫。

      EXPAT_INCLUDE_DIRS - where to find expat.h, etc.
      EXPAT_LIBRARIES    - List of libraries when using expat.
      EXPAT_FOUND        - True if expat found.
  • FindFLTK：尋找原生 FLTK include 和函式庫


    預設情況下，FindFLTK.cmake 將會搜尋所有 FLTK 組件並將它們新增到 FLTK_LIBRARIES 變數中。

       You can limit the components which get placed in FLTK_LIBRARIES by
       defining one or more of the following three options:


         FLTK_SKIP_OPENGL, set to true to disable searching for opengl and
                           the FLTK GL library
         FLTK_SKIP_FORMS, set to true to disable searching for fltk_forms
         FLTK_SKIP_IMAGES, set to true to disable searching for fltk_images


         FLTK_SKIP_FLUID, set to true if the fluid binary need not be present
                          at build time


    將會定義以下變數

         FLTK_FOUND, True if all components not skipped were found
         FLTK_INCLUDE_DIR, where to find include files
         FLTK_LIBRARIES, list of fltk libraries you should link against
         FLTK_FLUID_EXECUTABLE, where to find the Fluid tool
         FLTK_WRAP_UI, This enables the FLTK_WRAP_UI command


    會指派以下快取變數，但不應使用。請改為參閱 FLTK_LIBRARIES 變數。

         FLTK_BASE_LIBRARY   = the full path to fltk.lib
         FLTK_GL_LIBRARY     = the full path to fltk_gl.lib
         FLTK_FORMS_LIBRARY  = the full path to fltk_forms.lib
         FLTK_IMAGES_LIBRARY = the full path to fltk_images.lib
  • FindFLTK2：尋找原生 FLTK2 include 和函式庫

    定義了以下設定

      FLTK2_FLUID_EXECUTABLE, where to find the Fluid tool
      FLTK2_WRAP_UI, This enables the FLTK2_WRAP_UI command
      FLTK2_INCLUDE_DIR, where to find include files
      FLTK2_LIBRARIES, list of fltk2 libraries
      FLTK2_FOUND, Don't use FLTK2 if false.

    一般而言，不應使用以下設定。

      FLTK2_BASE_LIBRARY   = the full path to fltk2.lib
      FLTK2_GL_LIBRARY     = the full path to fltk2_gl.lib
      FLTK2_IMAGES_LIBRARY = the full path to fltk2_images.lib
  • FindFreetype：尋找 FreeType 函式庫

    此模組定義

      FREETYPE_LIBRARIES, the library to link against
      FREETYPE_FOUND, if false, do not try to link to FREETYPE
      FREETYPE_INCLUDE_DIRS, where to find headers.
      This is the concatenation of the paths:
      FREETYPE_INCLUDE_DIR_ft2build
      FREETYPE_INCLUDE_DIR_freetype2


    $FREETYPE_DIR 是一個環境變數，它對應於建置 FREETYPE 時使用的 ./configure --prefix=$FREETYPE_DIR。

  • FindGCCXML：尋找 GCC-XML 前端可執行檔。
  • FindGDAL:

    尋找 gdal

    此模組接受以下環境變數

        GDAL_DIR or GDAL_ROOT - Specify the location of GDAL


    此模組定義以下 CMake 變數

        GDAL_FOUND - True if libgdal is found
        GDAL_LIBRARY - A variable pointing to the GDAL library
        GDAL_INCLUDE_DIR - Where to find the headers


    $GDALDIR 是一個環境變數，它對應於建置 gdal 時使用的 ./configure --prefix=$GDAL_DIR。

    由 Eric Wing 建立。我不是 gdal 使用者，但 OpenSceneGraph 將其用於 osgTerrain，因此我為了完整性而將此模組放在一起。我實際上不知道慣例或檔案通常在發行版中放置的位置。鼓勵任何真正的 gdal 使用者更正此問題（但請不要在這樣做時破壞 OS X 框架的東西，這似乎是經常發生的事情）。

  • FindGIF:

    此模組定義 GIF_LIBRARIES - 為了使用 GIF 而連結的函式庫 GIF_FOUND，如果為 false，則不要嘗試連結 GIF_INCLUDE_DIR，在哪裡找到標頭

    $GIF_DIR 是一個環境變數，它對應於 ./configure --prefix=$GIF_DIR

  • FindGLUT：嘗試尋找 glut 函式庫和 include 檔案
      GLUT_INCLUDE_DIR, where to find GL/glut.h, etc.
      GLUT_LIBRARIES, the libraries to link against
      GLUT_FOUND, If false, do not try to use GLUT.

    也定義，但一般用途不是

      GLUT_glut_LIBRARY = the full path to the glut library.
      GLUT_Xmu_LIBRARY  = the full path to the Xmu library.
      GLUT_Xi_LIBRARY   = the full path to the Xi Library.
  • FindGTK：嘗試尋找 GTK (和 glib) 和 GTKGLArea
      GTK_INCLUDE_DIR   - Directories to include to use GTK
      GTK_LIBRARIES     - Files to link against to use GTK
      GTK_FOUND         - GTK was found
      GTK_GL_FOUND      - GTK's GL features were found
  • FindGettext：尋找 GNU gettext 工具

    此模組尋找 GNU gettext 工具。此模組定義以下值

      GETTEXT_MSGMERGE_EXECUTABLE: the full path to the msgmerge tool.
      GETTEXT_MSGFMT_EXECUTABLE: the full path to the msgfmt tool.
      GETTEXT_FOUND: True if gettext has been found.


    此外，它還提供以下巨集：GETTEXT_CREATE_TRANSLATIONS (輸出檔案 [ALL] 檔案 1 ... 檔案 N )

        This will create a target "translations" which will convert the 
        given input po files into the binary output mo file. If the 
        ALL option is used, the translations will also be created when
        building the default target.
  • FindGnuplot：此模組尋找 gnuplot


    完成後，這將定義

      GNUPLOT_FOUND - system has Gnuplot
      GNUPLOT_EXECUTABLE - the Gnuplot executable
  • FindHSPELL：嘗試尋找 HSPELL

    完成後，這將定義

      HSPELL_FOUND - system has HSPELL
      HSPELL_INCLUDE_DIR - the HSPELL include directory
      HSPELL_LIBRARIES - The libraries needed to use HSPELL
      HSPELL_DEFINITIONS - Compiler switches required for using HSPELL
  • FindHTMLHelp：此模組尋找 Microsoft HTML Help Compiler

    它定義

       HTML_HELP_COMPILER     : full path to the Compiler (hhc.exe)
       HTML_HELP_INCLUDE_PATH : include path to the API (htmlhelp.h)
       HTML_HELP_LIBRARY      : full path to the library (htmlhelp.lib)


  • FindITK：尋找 ITK 安裝或建置樹狀結構。
  • FindImageMagick：尋找 ImageMagick 二進位套件。

    此模組將搜尋在 FIND_PACKAGE 呼叫中指定為組件的一組 ImageMagick 工具。典型的組件包括但不限於（未來版本的 ImageMagick 可能具有此處未列出的其他組件）

      animate
      compare
      composite
      conjure
      convert
      display
      identify
      import
      mogrify
      montage
      stream


    如果在 FIND_PACKAGE 呼叫中未指定任何組件，則它只會搜尋 ImageMagick 可執行檔目錄。此程式碼會定義以下變數

      ImageMagick_FOUND                  - TRUE if all components are found.
      ImageMagick_EXECUTABLE_DIR         - Full path to executables directory.
      ImageMagick_<component>_FOUND      - TRUE if <component> is found.
      ImageMagick_<component>_EXECUTABLE - Full path to <component> executable.


    以下 ImageMagick API 也有對應的組件

      Magick++
      MagickWand
      MagickCore


    對於這些組件，將會設定以下變數

      ImageMagick_FOUND                    - TRUE if all components are found.
      ImageMagick_INCLUDE_DIRS             - Full paths to all include dirs.
      ImageMagick_LIBRARIES                - Full paths to all libraries.
      ImageMagick_<component>_FOUND        - TRUE if <component> is found.
      ImageMagick_<component>_INCLUDE_DIRS - Full path to <component> include dirs.
      ImageMagick_<component>_LIBRARIES    - Full path to <component> libraries.


    使用範例

      FIND_PACKAGE(ImageMagick)
      FIND_PACKAGE(ImageMagick COMPONENTS convert)
      FIND_PACKAGE(ImageMagick COMPONENTS convert mogrify display)
      FIND_PACKAGE(ImageMagick COMPONENTS Magick++)
      FIND_PACKAGE(ImageMagick COMPONENTS Magick++ convert)


    請注意，標準的 FIND_PACKAGE 功能（例如 QUIET、REQUIRED 等）均受支援。

  • FindJNI：尋找 JNI Java 程式庫。

    此模組會尋找是否已安裝 Java，並判斷標頭檔和程式庫的位置。它也會判斷程式庫的名稱。此程式碼會設定以下變數

       
      JNI_INCLUDE_DIRS      = the include dirs to use
      JNI_LIBRARIES         = the libraries to use
      JAVA_AWT_LIBRARY      = the path to the jawt library
      JAVA_JVM_LIBRARY      = the path to the jvm library
      JAVA_INCLUDE_PATH     = the include path to jni.h
      JAVA_INCLUDE_PATH2    = the include path to jni_md.h
      JAVA_AWT_INCLUDE_PATH = the include path to jawt.h


  • FindJPEG：尋找 JPEG

    尋找原生 JPEG 標頭檔和程式庫。此模組會定義

      JPEG_INCLUDE_DIR, where to find jpeglib.h, etc.
      JPEG_LIBRARIES, the libraries needed to use JPEG.
      JPEG_FOUND, If false, do not try to use JPEG.

    也定義了，但通常不使用

      JPEG_LIBRARY, where to find the JPEG library.
  • FindJasper：嘗試尋找 Jasper JPEG2000 程式庫

    完成後，這將定義

      JASPER_FOUND - system has Jasper
      JASPER_INCLUDE_DIR - the Jasper include directory
      JASPER_LIBRARIES - The libraries needed to use Jasper
  • FindJava：尋找 Java

    此模組會尋找是否已安裝 Java，並判斷標頭檔和程式庫的位置。此程式碼會設定以下變數

      JAVA_RUNTIME    = the full path to the Java runtime
      JAVA_COMPILE    = the full path to the Java compiler
      JAVA_ARCHIVE    = the full path to the Java archiver


  • FindKDE3：尋找 KDE3 標頭檔和程式庫目錄、KDE 前置處理器，並定義一些巨集


    此模組定義了以下變數

      KDE3_DEFINITIONS         - compiler definitions required for compiling KDE software
      KDE3_INCLUDE_DIR         - the KDE include directory
      KDE3_INCLUDE_DIRS        - the KDE and the Qt include directory, for use with INCLUDE_DIRECTORIES()
      KDE3_LIB_DIR             - the directory where the KDE libraries are installed, for use with LINK_DIRECTORIES()
      QT_AND_KDECORE_LIBS      - this contains both the Qt and the kdecore library
      KDE3_DCOPIDL_EXECUTABLE  - the dcopidl executable
      KDE3_DCOPIDL2CPP_EXECUTABLE - the dcopidl2cpp executable
      KDE3_KCFGC_EXECUTABLE    - the kconfig_compiler executable
      KDE3_FOUND               - set to TRUE if all of the above has been found


    提供以下使用者可調整的選項

      KDE3_BUILD_TESTS - enable this to build KDE testcases



    它還會加入以下巨集（來自 KDE3Macros.cmake）。SRCS_VAR 永遠是包含應用程式或程式庫原始檔清單的變數。

    KDE3_AUTOMOC(file1 ... fileN)

        Call this if you want to have automatic moc file handling.
        This means if you include "foo.moc" in the source file foo.cpp
        a moc file for the header foo.h will be created automatically.
        You can set the property SKIP_AUTOMAKE using SET_SOURCE_FILES_PROPERTIES()
        to exclude some files in the list from being processed.


    KDE3_ADD_MOC_FILES(SRCS_VAR file1 ... fileN )

        If you don't use the KDE3_AUTOMOC() macro, for the files
        listed here moc files will be created (named "foo.moc.cpp")


    KDE3_ADD_DCOP_SKELS(SRCS_VAR header1.h ... headerN.h )

        Use this to generate DCOP skeletions from the listed headers.


    KDE3_ADD_DCOP_STUBS(SRCS_VAR header1.h ... headerN.h )

         Use this to generate DCOP stubs from the listed headers.


    KDE3_ADD_UI_FILES(SRCS_VAR file1.ui ... fileN.ui )

        Use this to add the Qt designer ui files to your application/library.


    KDE3_ADD_KCFG_FILES(SRCS_VAR file1.kcfgc ... fileN.kcfgc )

        Use this to add KDE kconfig compiler files to your application/library.


    KDE3_INSTALL_LIBTOOL_FILE(target)

        This will create and install a simple libtool file for the given target.


    KDE3_ADD_EXECUTABLE(name file1 ... fileN )

        Currently identical to ADD_EXECUTABLE(), may provide some advanced features in the future.


    KDE3_ADD_KPART(name [WITH_PREFIX] file1 ... fileN )

        Create a KDE plugin (KPart, kioslave, etc.) from the given source files.
        If WITH_PREFIX is given, the resulting plugin will have the prefix "lib", otherwise it won't.
        It creates and installs an appropriate libtool la-file.


    KDE3_ADD_KDEINIT_EXECUTABLE(name file1 ... fileN )

        Create a KDE application in the form of a module loadable via kdeinit.
        A library named kdeinit_<name> will be created and a small executable which links to it.


    不再支援使用 KDE3_ENABLE_FINAL 選項來啟用一體編譯。


    作者：Alexander Neundorf <neundorf@kde.org>

  • FindKDE4:

    尋找 KDE4 並提供所有必要的變數和巨集來為其編譯軟體。它會依以下順序在以下目錄中尋找 KDE 4

      CMAKE_INSTALL_PREFIX
      KDEDIRS
      /opt/kde4


    請查看 FindKDE4Internal.cmake 和 KDE4Macros.cmake 以取得更多資訊。它們與 KDE 4 程式庫一起安裝在 $KDEDIRS/share/apps/cmake/modules/ 中。

    作者：Alexander Neundorf <neundorf@kde.org>

  • FindLAPACK：尋找 LAPACK 程式庫

    此模組會尋找已安裝的 Fortran 程式庫，該程式庫實作 LAPACK 線性代數介面 (請參閱 http://www.netlib.org/lapack/)。

    此方法遵循用於 autoconf 巨集檔案 acx_lapack.m4 的方法（分佈於 http://ac-archive.sourceforge.net/ac-archive/acx_lapack.html）。

    此模組設定以下變數

      LAPACK_FOUND - set to true if a library implementing the LAPACK interface
        is found
      LAPACK_LINKER_FLAGS - uncached list of required linker flags (excluding -l
        and -L).
      LAPACK_LIBRARIES - uncached list of libraries (using full path name) to
        link against to use LAPACK
      LAPACK95_LIBRARIES - uncached list of libraries (using full path name) to
        link against to use LAPACK95
      LAPACK95_FOUND - set to true if a library implementing the LAPACK f95
        interface is found
      BLA_STATIC  if set on this determines what kind of linkage we do (static)
      BLA_VENDOR  if set checks only the specified vendor, if not set checks
         all the posibilities
      BLA_F95     if set on tries to find the f95 interfaces for BLAS/LAPACK

    ## 此模組中有效的供應商清單 (BLA_VENDOR) # Intel(mkl)、ACML、Apple、NAS、Generic

  • FindLATEX：尋找 Latex

    此模組會尋找是否已安裝 Latex，並判斷可執行檔的位置。此程式碼會設定以下變數

      
      LATEX_COMPILER:       path to the LaTeX compiler
      PDFLATEX_COMPILER:    path to the PdfLaTeX compiler
      BIBTEX_COMPILER:      path to the BibTeX compiler
      MAKEINDEX_COMPILER:   path to the MakeIndex compiler
      DVIPS_CONVERTER:      path to the DVIPS converter
      PS2PDF_CONVERTER:     path to the PS2PDF converter
      LATEX2HTML_CONVERTER: path to the LaTeX2Html converter


  • FindLibXml2：嘗試尋找 LibXml2

    完成後，這將定義

      LIBXML2_FOUND - System has LibXml2
      LIBXML2_INCLUDE_DIR - The LibXml2 include directory
      LIBXML2_LIBRARIES - The libraries needed to use LibXml2
      LIBXML2_DEFINITIONS - Compiler switches required for using LibXml2
      LIBXML2_XMLLINT_EXECUTABLE - The XML checking tool xmllint coming with LibXml2
  • FindLibXslt：嘗試尋找 LibXslt

    完成後，這將定義

      LIBXSLT_FOUND - system has LibXslt
      LIBXSLT_INCLUDE_DIR - the LibXslt include directory
      LIBXSLT_LIBRARIES - Link these to LibXslt
      LIBXSLT_DEFINITIONS - Compiler switches required for using LibXslt
  • FindLua50:

    尋找 Lua 程式庫。此模組會定義

      LUA50_FOUND, if false, do not try to link to Lua 
      LUA_LIBRARIES, both lua and lualib
      LUA_INCLUDE_DIR, where to find lua.h and lualib.h (and probably lauxlib.h)


    請注意，預期的標頭檔包含慣例是

      #include "lua.h"

    而不是

      #include <lua/lua.h>

    這是因為 Lua 的位置並未標準化，可能存在於 lua/ 以外的位置。

  • FindLua51:

    尋找 Lua 程式庫。此模組會定義

      LUA51_FOUND, if false, do not try to link to Lua 
      LUA_LIBRARIES
      LUA_INCLUDE_DIR, where to find lua.h


    請注意，預期的標頭檔包含慣例是

      #include "lua.h"

    而不是

      #include <lua/lua.h>

    這是因為 Lua 的位置並未標準化，可能存在於 lua/ 以外的位置。

  • FindMFC：在 Windows 上尋找 MFC

    尋找原生 MFC，即決定應用程式是否可以連結到 MFC 程式庫。

      MFC_FOUND - Was MFC support found

    您不需要包含任何內容或連結任何內容即可使用它。

  • FindMPEG：尋找原生 MPEG 標頭檔和程式庫

    此模組定義

      MPEG_INCLUDE_DIR, where to find MPEG.h, etc.
      MPEG_LIBRARIES, the libraries required to use MPEG.
      MPEG_FOUND, If false, do not try to use MPEG.

    也定義了，但通常不使用

      MPEG_mpeg2_LIBRARY, where to find the MPEG library.
      MPEG_vo_LIBRARY, where to find the vo library.
  • FindMPEG2：尋找原生 MPEG2 標頭檔和程式庫

    此模組定義

      MPEG2_INCLUDE_DIR, path to mpeg2dec/mpeg2.h, etc.
      MPEG2_LIBRARIES, the libraries required to use MPEG2.
      MPEG2_FOUND, If false, do not try to use MPEG2.

    也定義了，但通常不使用

      MPEG2_mpeg2_LIBRARY, where to find the MPEG2 library.
      MPEG2_vo_LIBRARY, where to find the vo library.
  • FindMPI：訊息傳遞介面 (MPI) 模組。


    訊息傳遞介面 (MPI) 是一個用於撰寫使用訊息傳遞的高效能並行應用程式的程式庫，通常部署在叢集上。MPI 是一個標準介面（由 MPI 論壇定義），有多種實作方式。所有這些實作都有略有不同的編譯方法（不同的標頭檔路徑、要連結的程式庫等），而此模組會嘗試消除這些差異。

    此模組會設定以下變數

       MPI_FOUND                  TRUE if we have found MPI
       MPI_COMPILE_FLAGS          Compilation flags for MPI programs
       MPI_INCLUDE_PATH           Include path(s) for MPI header
       MPI_LINK_FLAGS             Linking flags for MPI programs
       MPI_LIBRARY                First MPI library to link against (cached)
       MPI_EXTRA_LIBRARY          Extra MPI libraries to link against (cached)
       MPI_LIBRARIES              All libraries to link MPI programs against
       MPIEXEC                    Executable for running MPI programs
       MPIEXEC_NUMPROC_FLAG       Flag to pass to MPIEXEC before giving it the
                                  number of processors to run on
       MPIEXEC_PREFLAGS           Flags to pass to MPIEXEC directly before the
                                  executable to run.
       MPIEXEC_POSTFLAGS          Flags to pass to MPIEXEC after all other flags.


    此模組會嘗試自動偵測這些設定，首先是尋找 MPI 編譯器，許多 MPI 實作會提供 MPI 編譯器，將其作為原生編譯器的傳遞，以簡化 MPI 程式的編譯。MPI 編譯器儲存在快取變數 MPI_COMPILER 中，並會嘗試尋找常用的驅動程式名稱 mpic++、mpicxx、mpiCC 或 mpicc。如果找到並識別出編譯器驅動程式，則會使用它來設定所有模組變數。若要略過此自動偵測，請在 CMake 快取中設定 MPI_LIBRARY 和 MPI_INCLUDE_PATH。

    如果找不到編譯器驅動程式或編譯器驅動程式無法識別，此模組會接著搜尋常見的標頭檔路徑和程式庫名稱，嘗試偵測 MPI。

    如果 CMake 最初找到與預期不同的 MPI，而您想要針對其他 MPI 實作使用 MPI 編譯器自動偵測，請將 MPI_COMPILER 設定為您想要使用的 MPI 編譯器驅動程式 (例如，mpicxx)，然後將 MPI_LIBRARY 設定為字串 MPI_LIBRARY-NOTFOUND。當您重新設定時，MPI 的自動偵測將會使用新指定的 MPI_COMPILER 再次執行。

    當使用 MPIEXEC 執行 MPI 應用程式時，您通常應該使用所有 MPIEXEC 旗標，如下所示

       ${MPIEXEC} ${MPIEXEC_NUMPROC_FLAG} PROCS ${MPIEXEC_PREFLAGS} EXECUTABLE
         ${MPIEXEC_POSTFLAGS} ARGS

    其中 PROCS 是執行程式的處理器數目，EXECUTABLE 是 MPI 程式，而 ARGS 是要傳遞給 MPI 程式的引數。

  • FindMatlab：此模組會尋找 Matlab

    定義

      MATLAB_INCLUDE_DIR: include path for mex.h, engine.h
      MATLAB_LIBRARIES:   required libraries: libmex, etc
      MATLAB_MEX_LIBRARY: path to libmex.lib
      MATLAB_MX_LIBRARY:  path to libmx.lib
      MATLAB_ENG_LIBRARY: path to libeng.lib
  • FindMotif：嘗試尋找 Motif（或 lesstif）

    完成後，這將定義

      MOTIF_FOUND        - system has MOTIF
      MOTIF_INCLUDE_DIR  - incude paths to use Motif
      MOTIF_LIBRARIES    - Link these to use Motif
  • FindOpenAL:

    尋找 OpenAL。此模組會定義 OPENAL_LIBRARY、OPENAL_FOUND（如果為 false，則不要嘗試連結到 OpenAL）、OPENAL_INCLUDE_DIR（尋找標頭檔的位置）

    $OPENALDIR 是一個環境變數，對應於建置 OpenAL 時所用的 ./configure --prefix=$OPENALDIR。

    由 Eric Wing 建立。此模組受到 FindSDL.cmake 模組的影響。

  • FindOpenGL：嘗試尋找 OpenGL

    完成後，這將定義

      
      OPENGL_FOUND        - system has OpenGL
      OPENGL_XMESA_FOUND  - system has XMESA
      OPENGL_GLU_FOUND    - system has GLU
      OPENGL_INCLUDE_DIR  - the GL include directory
      OPENGL_LIBRARIES    - Link these to use OpenGL and GLU

    如果您只想使用 GL，則可以使用這些值

      OPENGL_gl_LIBRARY   - Path to OpenGL Library
      OPENGL_glu_LIBRARY  - Path to GLU Library

    在 OSX 上，預設為使用 OpenGL 的框架版本。人們必須變更 OPENGL_glu_LIBRARY 和 OPENGL_gl_LIBRARY 的快取值，才能在 OSX 上使用 X11 的 OpenGL。

  • FindOpenMP：尋找 OpenMP 支援

    此模組可用於偵測編譯器中的 OpenMP 支援。如果編譯器支援 OpenMP，則會設定使用 OpenMP 支援進行編譯所需的旗標。

    會設定以下變數

       OpenMP_C_FLAGS - flags to add to the C compiler for OpenMP support
       OpenMP_CXX_FLAGS - flags to add to the CXX compiler for OpenMP support
       OPENMP_FOUND - true if openmp is detected


    支援的編譯器可在此處找到：http://openmp.org/wp/openmp-compilers/

  • FindOpenSSL：嘗試尋找 OpenSSL 加密程式庫

    完成後，這將定義

      OPENSSL_FOUND - system has the OpenSSL library
      OPENSSL_INCLUDE_DIR - the OpenSSL include directory
      OPENSSL_LIBRARIES - The libraries needed to use OpenSSL
  • FindOpenSceneGraph：尋找 OpenSceneGraph

    此模組會搜尋 OpenSceneGraph 核心 "osg" 程式庫，以及 OpenThreads，以及您指定的任何其他 COMPONENTS。

        See http://www.openscenegraph.org


    注意：如果您想要在 CMAKE_MODULE_PATH 中使用此模組，而不是要求 CMake >= 2.6.3，您還需要下載 FindOpenThreads.cmake、Findosg_functions.cmake、Findosg.cmake，以及您需要呼叫的任何元件檔案 (FindosgDB.cmake、FindosgUtil.cmake 等)。

    ==================================

    此模組接受以下變數（請注意大小寫混合）

        OpenSceneGraph_DEBUG - Enable debugging output


        OpenSceneGraph_MARK_AS_ADVANCED - Mark cache variables as advanced 
                                          automatically


    以下環境變數也適用於尋找 OSG 及其各種元件。CMAKE_PREFIX_PATH 也可用於此 (請參閱 find_library() CMake 文件)。

        <MODULE>_DIR (where MODULE is of the form "OSGVOLUME" and there is a FindosgVolume.cmake file)
        OSG_DIR
        OSGDIR
        OSG_ROOT


    此模組會定義以下輸出變數

        OPENSCENEGRAPH_FOUND - Was the OSG and all of the specified components found?


        OPENSCENEGRAPH_VERSION - The version of the OSG which was found


        OPENSCENEGRAPH_INCLUDE_DIRS - Where to find the headers


        OPENSCENEGRAPH_LIBRARIES - The OSG libraries


    ================================== 使用範例

      find_package(OpenSceneGraph 2.0.0 COMPONENTS osgDB osgUtil)
      include_directories(${OPENSCENEGRAPH_INCLUDE_DIRS})


      add_executable(foo foo.cc)
      target_link_libraries(foo ${OPENSCENEGRAPH_LIBRARIES})


    ==================================

    命名慣例

      Local variables of the form _osg_foo
      Input variables of the form OpenSceneGraph_FOO
      Output variables of the form OPENSCENEGRAPH_FOO


    版權 (c) 2009, Philip Lowman <philip@yhbt.com>

    根據新 BSD 授權條款，允許重新散布和使用。如需詳細資訊，請參閱隨附的 COPYING-CMAKE-SCRIPTS 檔案。

    ==================================

  • FindOpenThreads:

    OpenThreads 是一個基於 C++ 的執行緒程式庫。其最大的使用者群似乎是 OpenSceneGraph，因此您可能會注意到我接受 OSGDIR 作為環境路徑。我將其視為用於尋找 OpenSceneGraph 元件的 Findosg* 套件的一部分。每個元件都是獨立的，您必須選擇加入每個模組。

    尋找 OpenThreads。此模組會定義 OPENTHREADS_LIBRARY、OPENTHREADS_FOUND（如果為 false，則不要嘗試連結到 OpenThreads）、OPENTHREADS_INCLUDE_DIR（尋找標頭檔的位置）

    $OPENTHREADS_DIR 是一個環境變數，對應於建置 osg 時所用的 ./configure --prefix=$OPENTHREADS_DIR。

    由 Eric Wing 建立。

  • FindPHP4：尋找 PHP4

    此模組會尋找是否已安裝 PHP4，並判斷標頭檔和程式庫的位置。它也會判斷程式庫的名稱。此程式碼會設定以下變數

      PHP4_INCLUDE_PATH       = path to where php.h can be found
      PHP4_EXECUTABLE         = full path to the php4 binary


  • FindPNG：尋找原生 PNG 標頭檔和程式庫


    此模組定義

      PNG_INCLUDE_DIR, where to find png.h, etc.
      PNG_LIBRARIES, the libraries to link against to use PNG.
      PNG_DEFINITIONS - You should ADD_DEFINITONS(${PNG_DEFINITIONS}) before compiling code that includes png library files.
      PNG_FOUND, If false, do not try to use PNG.

    也定義了，但通常不使用

      PNG_LIBRARY, where to find the PNG library.

    除非可以找到 zlib，否則不會定義上述任何項目。PNG 依賴於 Zlib。

  • FindPackageHandleStandardArgs:

    FIND_PACKAGE_HANDLE_STANDARD_ARGS(NAME (DEFAULT_MSG|"自訂失敗訊息") VAR1 ... )

        This macro is intended to be used in FindXXX.cmake modules files.
        It handles the REQUIRED and QUIET argument to FIND_PACKAGE() and
        it also sets the <UPPERCASED_NAME>_FOUND variable.
        The package is found if all variables listed are TRUE.
        Example:


        FIND_PACKAGE_HANDLE_STANDARD_ARGS(LibXml2 DEFAULT_MSG LIBXML2_LIBRARIES LIBXML2_INCLUDE_DIR)


        LibXml2 is considered to be found, if both LIBXML2_LIBRARIES and 
        LIBXML2_INCLUDE_DIR are valid. Then also LIBXML2_FOUND is set to TRUE.
        If it is not found and REQUIRED was used, it fails with FATAL_ERROR, 
        independent whether QUIET was used or not.
        If it is found, the location is reported using the VAR1 argument, so 
        here a message "Found LibXml2: /usr/lib/libxml2.so" will be printed out.
        If the second argument is DEFAULT_MSG, the message in the failure case will 
        be "Could NOT find LibXml2", if you don't like this message you can specify
        your own custom failure message there.
  • FindPackageMessage:

    FIND_PACKAGE_MESSAGE(<name> "使用者訊息" "尋找結果詳細資訊")

    此巨集旨在用於 FindXXX.cmake 模組檔案中。它會針對每個唯一的尋找結果列印一次訊息。這對於告訴使用者套件的尋找位置很有用。第一個引數指定套件的名稱 (XXX)。第二個引數指定要顯示的訊息。第三個引數列出尋找結果的詳細資訊，以便在它們變更時再次顯示訊息。此巨集也遵循 find_package 命令的 QUIET 引數。

    範例

      IF(X11_FOUND)
        FIND_PACKAGE_MESSAGE(X11 "Found X11: ${X11_X11_LIB}"
          "[${X11_X11_LIB}][${X11_INCLUDE_DIR}]")
      ELSE(X11_FOUND)
       ...
      ENDIF(X11_FOUND)
  • FindPerl：尋找 perl

    此模組會尋找 Perl

      PERL_EXECUTABLE - the full path to perl
      PERL_FOUND      - If false, don't attempt to use perl.
  • FindPerlLibs：尋找 Perl 程式庫

    此模組會尋找是否已安裝 PERL，並判斷標頭檔和程式庫的位置。它也會判斷程式庫的名稱。此程式碼會設定以下變數

      PERL_INCLUDE_PATH = path to where perl.h is found
      PERL_EXECUTABLE   = full path to the perl binary


  • FindPhysFS:

    尋找 PhysFS 程式庫。此模組會定義 PHYSFS_LIBRARY（要連結的程式庫名稱）、PHYSFS_FOUND（如果為 false，則不要嘗試連結到 PHYSFS）、PHYSFS_INCLUDE_DIR（尋找 physfs.h 的位置）

    $PHYSFSDIR 是一個環境變數，對應於建置 PHYSFS 時所用的 ./configure --prefix=$PHYSFSDIR。

    由 Eric Wing 建立。

  • FindPike：尋找 Pike

    此模組會尋找是否已安裝 PIKE，並判斷標頭檔和程式庫的位置。它也會判斷程式庫的名稱。此程式碼會設定以下變數

      PIKE_INCLUDE_PATH       = path to where program.h is found
      PIKE_EXECUTABLE         = full path to the pike binary


  • FindPkgConfig：用於 CMake 的 pkg-config 模組


    用法

       pkg_check_modules(<PREFIX> [REQUIRED] <MODULE> [<MODULE>]*)
         checks for all the given modules


       pkg_search_module(<PREFIX> [REQUIRED] <MODULE> [<MODULE>]*)
         checks for given modules and uses the first working one


    當設定 'REQUIRED' 引數時，如果找不到模組，巨集會失敗並產生錯誤

    它會設定以下變數

       PKG_CONFIG_FOUND         ... true if pkg-config works on the system
       PKG_CONFIG_EXECUTABLE    ... pathname of the pkg-config program
       <PREFIX>_FOUND           ... set to 1 if module(s) exist


    對於以下變數，存在兩組值；第一組是通用的，且具有給定的 PREFIX。第二組包含在呼叫 pkgconfig 時使用 '--static' 選項所提供的旗標。

       <XPREFIX>_LIBRARIES      ... only the libraries (w/o the '-l')
       <XPREFIX>_LIBRARY_DIRS   ... the paths of the libraries (w/o the '-L')
       <XPREFIX>_LDFLAGS        ... all required linker flags
       <XPREFIX>_LDFLAGS_OTHER  ... all other linker flags
       <XPREFIX>_INCLUDE_DIRS   ... the '-I' preprocessor flags (w/o the '-I')
       <XPREFIX>_CFLAGS         ... all required cflags
       <XPREFIX>_CFLAGS_OTHER   ... the other compiler flags


       <XPREFIX> = <PREFIX>        for common case
       <XPREFIX> = <PREFIX>_STATIC for static linking


    有一些特殊的變數，其前綴會根據給定模組的數量而定。當只有一個模組時，<PREFIX> 維持不變。當有多個模組時，前綴會變更為 <PREFIX>_<MODNAME>。

       <XPREFIX>_VERSION    ... version of the module
       <XPREFIX>_PREFIX     ... prefix-directory of the module
       <XPREFIX>_INCLUDEDIR ... include-dir of the module
       <XPREFIX>_LIBDIR     ... lib-dir of the module


       <XPREFIX> = <PREFIX>  when |MODULES| == 1, else
       <XPREFIX> = <PREFIX>_<MODNAME>


    一個 <MODULE> 參數可以有以下格式：

       {MODNAME}            ... matches any version
       {MODNAME}>={VERSION} ... at least version <VERSION> is required
       {MODNAME}={VERSION}  ... exactly version <VERSION> is required
       {MODNAME}<={VERSION} ... modules must not be newer than <VERSION>


    範例

       pkg_check_modules (GLIB2   glib-2.0)


       pkg_check_modules (GLIB2   glib-2.0>=2.10)
         requires at least version 2.10 of glib2 and defines e.g.
           GLIB2_VERSION=2.10.3


       pkg_check_modules (FOO     glib-2.0>=2.10 gtk+-2.0)
         requires both glib2 and gtk2, and defines e.g.
           FOO_glib-2.0_VERSION=2.10.3
           FOO_gtk+-2.0_VERSION=2.8.20


       pkg_check_modules (XRENDER REQUIRED xrender)
         defines e.g.:
           XRENDER_LIBRARIES=Xrender;X11
           XRENDER_STATIC_LIBRARIES=Xrender;X11;pthread;Xau;Xdmcp


       pkg_search_module (BAR     libxml-2.0 libxml2 libxml>=2)
  • FindProducer:

    雖然 Producer 並非 OpenSceneGraph 的直接一部分，但其主要使用者是 OSG，因此我將其視為 Findosg* 套件的一部分，用於尋找 OpenSceneGraph 元件。你會注意到我接受 OSGDIR 作為環境路徑。

    每個元件都是獨立的，你必須選擇加入每個模組。你還必須選擇加入 OpenGL (和 OpenThreads?)，因為這些模組不會為你執行此操作。這樣做的目的是讓你逐個控制自己的系統，以防你需要選擇退出某些元件或變更特定模組的 Find 行為（例如，因為預設的 FindOpenGL.cmake 模組無法在你的系統上運作）。如果你想使用一個更方便、包含所有內容的模組，請使用 FindOpenSceneGraph.cmake 而不是 Findosg*.cmake 模組。

    尋找 Producer。此模組定義了 PRODUCER_LIBRARY、PRODUCER_FOUND (如果為 false，則不要嘗試連結到 Producer) 和 PRODUCER_INCLUDE_DIR (用於尋找標頭檔)。

    $PRODUCER_DIR 是一個環境變數，對應於在建置 osg 時使用的 ./configure --prefix=$PRODUCER_DIR。

    由 Eric Wing 建立。

  • FindPythonInterp：尋找 Python 直譯器

    此模組會尋找是否已安裝 Python 直譯器，並確定可執行檔的位置。此程式碼會設定以下變數：

      PYTHONINTERP_FOUND - Was the Python executable found
      PYTHON_EXECUTABLE  - path to the Python interpreter


  • FindPythonLibs：尋找 Python 函式庫

    此模組會尋找是否已安裝 Python，並確定標頭檔和函式庫的位置。它也會確定函式庫的名稱。此程式碼會設定以下變數：

      PYTHONLIBS_FOUND     = have the Python libs been found
      PYTHON_LIBRARIES     = path to the python library
      PYTHON_INCLUDE_PATH  = path to where Python.h is found
      PYTHON_DEBUG_LIBRARIES = path to the debug library


  • FindQt：搜尋所有已安裝的 QT 版本。

    只有在你的專案可以與多個版本的 QT 搭配使用時，才應該使用此模組。如果不是，你應該直接使用 FindQt4 或 FindQt3。如果在機器上找到多個版本的 QT，則使用者必須將選項 DESIRED_QT_VERSION 設定為他們想要使用的版本。如果在機器上只找到一個版本的 qt，則 DESIRED_QT_VERSION 會設定為該版本，並包含相符的 FindQt3 或 FindQt4 模組。一旦使用者設定了 DESIRED_QT_VERSION，就會包含 FindQt3 或 FindQt4 模組。

      QT_REQUIRED if this is set to TRUE then if CMake can 
                  not find QT4 or QT3 an error is raised 
                  and a message is sent to the user.


      DESIRED_QT_VERSION OPTION is created
      QT4_INSTALLED is set to TRUE if qt4 is found.
      QT3_INSTALLED is set to TRUE if qt3 is found.
  • FindQt3：尋找 Qt 包含路徑和函式庫

    此模組定義

      QT_INCLUDE_DIR - where to find qt.h, etc.
      QT_LIBRARIES   - the libraries to link against to use Qt.
      QT_DEFINITIONS - definitions to use when
                       compiling code that uses Qt.
      QT_FOUND       - If false, don't try to use Qt.


    如果你需要 Qt 的多執行緒版本，請將 QT_MT_REQUIRED 設定為 TRUE。

    也定義，但一般用途不是

      QT_MOC_EXECUTABLE, where to find the moc tool.
      QT_UIC_EXECUTABLE, where to find the uic tool.
      QT_QT_LIBRARY, where to find the Qt library.
      QT_QTMAIN_LIBRARY, where to find the qtmain
       library. This is only required by Qt3 on Windows.
  • FindQt4：尋找 QT 4

    此模組可用於尋找 Qt4。最重要的問題是 Qt4 qmake 可透過系統路徑取得。然後，這個 qmake 用於偵測基本上所有其他內容。此模組定義了一些關鍵的變數和巨集。首先是 QT_USE_FILE，它是 CMake 檔案的路徑，可以包含該檔案以編譯 Qt 4 應用程式和函式庫。預設情況下，會載入 QtCore 和 QtGui 函式庫。此行為可以透過在執行 INCLUDE(${QT_USE_FILE}) 之前將以下一個或多個變數設定為 true 來變更：

                        QT_DONT_USE_QTCORE
                        QT_DONT_USE_QTGUI
                        QT_USE_QT3SUPPORT
                        QT_USE_QTASSISTANT
                        QT_USE_QAXCONTAINER
                        QT_USE_QAXSERVER
                        QT_USE_QTDESIGNER
                        QT_USE_QTMOTIF
                        QT_USE_QTMAIN
                        QT_USE_QTNETWORK
                        QT_USE_QTNSPLUGIN
                        QT_USE_QTOPENGL
                        QT_USE_QTSQL
                        QT_USE_QTXML
                        QT_USE_QTSVG
                        QT_USE_QTTEST
                        QT_USE_QTUITOOLS
                        QT_USE_QTDBUS
                        QT_USE_QTSCRIPT
                        QT_USE_QTASSISTANTCLIENT
                        QT_USE_QTHELP
                        QT_USE_QTWEBKIT
                        QT_USE_QTXMLPATTERNS
                        QT_USE_PHONON


    QT_USE_FILE 所指向的檔案將會透過新增包含目錄、前處理器定義，以及填入包含所有 Qt 函式庫及其相依性的 QT_LIBRARIES 變數，來設定你的編譯環境。將 QT_LIBRARIES 變數新增到你的 TARGET_LINK_LIBRARIES。

    典型的用法可能是類似這樣：

       FIND_PACKAGE(Qt4)
       SET(QT_USE_QTXML 1)
       INCLUDE(${QT_USE_FILE})
       ADD_EXECUTABLE(myexe main.cpp)
       TARGET_LINK_LIBRARIES(myexe ${QT_LIBRARIES})



    還有一些檔案需要由一些 Qt 工具處理，例如 moc 和 uic。以下列出可用於處理這些檔案的巨集。

      
      macro QT4_WRAP_CPP(outfiles inputfile ... OPTIONS ...)
            create moc code from a list of files containing Qt class with
            the Q_OBJECT declaration.  Per-direcotry preprocessor definitions 
            are also added.  Options may be given to moc, such as those found
            when executing "moc -help".  


      macro QT4_WRAP_UI(outfiles inputfile ... OPTIONS ...)
            create code from a list of Qt designer ui files.
            Options may be given to uic, such as those found
            when executing "uic -help"


      macro QT4_ADD_RESOURCES(outfiles inputfile ... OPTIONS ...)
            create code from a list of Qt resource files.
            Options may be given to rcc, such as those found
            when executing "rcc -help"


      macro QT4_GENERATE_MOC(inputfile outputfile )
            creates a rule to run moc on infile and create outfile.
            Use this if for some reason QT4_WRAP_CPP() isn't appropriate, e.g.
            because you need a custom filename for the moc file or something similar.


      macro QT4_AUTOMOC(sourcefile1 sourcefile2 ... )
            This macro is still experimental.
            It can be used to have moc automatically handled.
            So if you have the files foo.h and foo.cpp, and in foo.h a 
            a class uses the Q_OBJECT macro, moc has to run on it. If you don't
            want to use QT4_WRAP_CPP() (which is reliable and mature), you can insert
            #include "foo.moc"
            in foo.cpp and then give foo.cpp as argument to QT4_AUTOMOC(). This will the
            scan all listed files at cmake-time for such included moc files and if it finds
            them cause a rule to be generated to run moc at build time on the 
            accompanying header file foo.h.
            If a source file has the SKIP_AUTOMOC property set it will be ignored by this macro.


      macro QT4_ADD_DBUS_INTERFACE(outfiles interface basename)
            create a the interface header and implementation files with the 
            given basename from the given interface xml file and add it to 
            the list of sources


      macro QT4_ADD_DBUS_INTERFACES(outfiles inputfile ... )
            create the interface header and implementation files 
            for all listed interface xml files
            the name will be automatically determined from the name of the xml file


      macro QT4_ADD_DBUS_ADAPTOR(outfiles xmlfile parentheader parentclassname [basename] )
            create a dbus adaptor (header and implementation file) from the xml file
            describing the interface, and add it to the list of sources. The adaptor
            forwards the calls to a parent class, defined in parentheader and named
            parentclassname. The name of the generated files will be
            <basename>adaptor.{cpp,h} where basename is the basename of the xml file.


      macro QT4_GENERATE_DBUS_INTERFACE( header [interfacename] )
            generate the xml interface file from the given header.
            If the optional argument interfacename is omitted, the name of the 
            interface file is constructed from the basename of the header with
            the suffix .xml appended.


      macro QT4_CREATE_TRANSLATION( qm_files directories ... sources ... 
                                    ts_files ... OPTIONS ...)
            out: qm_files
            in:  directories sources ts_files
            options: flags to pass to lupdate, such as -extensions to specify
            extensions for a directory scan.
            generates commands to create .ts (vie lupdate) and .qm
            (via lrelease) - files from directories and/or sources. The ts files are 
            created and/or updated in the source tree (unless given with full paths).
            The qm files are generated in the build tree.
            Updating the translations can be done by adding the qm_files
            to the source list of your library/executable, so they are
            always updated, or by adding a custom target to control when
            they get updated/generated.


      macro QT4_ADD_TRANSLATION( qm_files ts_files ... )
            out: qm_files
            in:  ts_files
            generates commands to create .qm from .ts - files. The generated
            filenames can be found in qm_files. The ts_files
            must exists and are not updated in any way.



      QT_FOUND         If false, don't try to use Qt.
      QT4_FOUND        If false, don't try to use Qt 4.


      QT_VERSION_MAJOR The major version of Qt found.
      QT_VERSION_MINOR The minor version of Qt found.
      QT_VERSION_PATCH The patch version of Qt found.


      QT_EDITION               Set to the edition of Qt (i.e. DesktopLight)
      QT_EDITION_DESKTOPLIGHT  True if QT_EDITION == DesktopLight
      QT_QTCORE_FOUND          True if QtCore was found.
      QT_QTGUI_FOUND           True if QtGui was found.
      QT_QT3SUPPORT_FOUND      True if Qt3Support was found.
      QT_QTASSISTANT_FOUND     True if QtAssistant was found.
      QT_QAXCONTAINER_FOUND     True if QAxContainer was found (Windows only).
      QT_QAXSERVER_FOUND          True if QAxServer was found (Windows only).
      QT_QTDBUS_FOUND          True if QtDBus was found.
      QT_QTDESIGNER_FOUND      True if QtDesigner was found.
      QT_QTDESIGNERCOMPONENTS  True if QtDesignerComponents was found.
      QT_QTMOTIF_FOUND         True if QtMotif was found.
      QT_QTNETWORK_FOUND       True if QtNetwork was found.
      QT_QTNSPLUGIN_FOUND      True if QtNsPlugin was found.
      QT_QTOPENGL_FOUND        True if QtOpenGL was found.
      QT_QTSQL_FOUND           True if QtSql was found.
      QT_QTXML_FOUND           True if QtXml was found.
      QT_QTSVG_FOUND           True if QtSvg was found.
      QT_QTSCRIPT_FOUND        True if QtScript was found.
      QT_QTTEST_FOUND          True if QtTest was found.
      QT_QTUITOOLS_FOUND       True if QtUiTools was found.
      QT_QTASSISTANTCLIENT_FOUND  True if QtAssistantClient was found.
      QT_QTHELP_FOUND          True if QtHelp was found.
      QT_QTWEBKIT_FOUND        True if QtWebKit was found.
      QT_QTXMLPATTERNS_FOUND   True if QtXmlPatterns was found.
      QT_PHONON_FOUND          True if phonon was found.



      QT_DEFINITIONS   Definitions to use when compiling code that uses Qt.
                       You do not need to use this if you include QT_USE_FILE.
                       The QT_USE_FILE will also define QT_DEBUG and QT_NO_DEBUG
                       to fit your current build type.  Those are not contained
                       in QT_DEFINITIONS.
                      
      QT_INCLUDES      List of paths to all include directories of 
                       Qt4 QT_INCLUDE_DIR and QT_QTCORE_INCLUDE_DIR are
                       always in this variable even if NOTFOUND,
                       all other INCLUDE_DIRS are
                       only added if they are found.
                       You do not need to use this if you include QT_USE_FILE.
       


      Include directories for the Qt modules are listed here.
      You do not need to use these variables if you include QT_USE_FILE.


      QT_INCLUDE_DIR              Path to "include" of Qt4
      QT_QT3SUPPORT_INCLUDE_DIR   Path to "include/Qt3Support" 
      QT_QTASSISTANT_INCLUDE_DIR  Path to "include/QtAssistant" 
      QT_QAXCONTAINER_INCLUDE_DIR  Path to "include/ActiveQt" (Windows only)
      QT_QAXSERVER_INCLUDE_DIR  Path to "include/ActiveQt" (Windows only)
      QT_QTCORE_INCLUDE_DIR       Path to "include/QtCore"         
      QT_QTDESIGNER_INCLUDE_DIR   Path to "include/QtDesigner" 
      QT_QTDESIGNERCOMPONENTS_INCLUDE_DIR   Path to "include/QtDesigner"
      QT_QTDBUS_INCLUDE_DIR       Path to "include/QtDBus" 
      QT_QTGUI_INCLUDE_DIR        Path to "include/QtGui" 
      QT_QTMOTIF_INCLUDE_DIR      Path to "include/QtMotif" 
      QT_QTNETWORK_INCLUDE_DIR    Path to "include/QtNetwork" 
      QT_QTNSPLUGIN_INCLUDE_DIR   Path to "include/QtNsPlugin" 
      QT_QTOPENGL_INCLUDE_DIR     Path to "include/QtOpenGL" 
      QT_QTSQL_INCLUDE_DIR        Path to "include/QtSql" 
      QT_QTXML_INCLUDE_DIR        Path to "include/QtXml" 
      QT_QTSVG_INCLUDE_DIR        Path to "include/QtSvg"
      QT_QTSCRIPT_INCLUDE_DIR     Path to "include/QtScript"
      QT_QTTEST_INCLUDE_DIR       Path to "include/QtTest"
      QT_QTASSISTANTCLIENT_INCLUDE_DIR       Path to "include/QtAssistant"
      QT_QTHELP_INCLUDE_DIR       Path to "include/QtHelp"
      QT_QTWEBKIT_INCLUDE_DIR     Path to "include/QtWebKit"
      QT_QTXMLPATTERNS_INCLUDE_DIR  Path to "include/QtXmlPatterns"
      QT_PHONON_INCLUDE_DIR       Path to "include/phonon"
                                
      QT_BINARY_DIR               Path to "bin" of Qt4
      QT_LIBRARY_DIR              Path to "lib" of Qt4
      QT_PLUGINS_DIR              Path to "plugins" for Qt4
      QT_TRANSLATIONS_DIR         Path to "translations" of Qt4
      QT_DOC_DIR                  Path to "doc" of Qt4
      QT_MKSPECS_DIR              Path to "mkspecs" of Qt4


    Qt 工具組可能同時包含除錯和發佈函式庫。在這種情況下，以下函式庫變數將同時包含這兩者。如果你包含 QT_USE_FILE 並使用 QT_LIBRARIES，則不需要使用這些變數。

      QT_QT3SUPPORT_LIBRARY            The Qt3Support library
      QT_QTASSISTANT_LIBRARY           The QtAssistant library
      QT_QAXCONTAINER_LIBRARY           The QAxContainer library (Windows only)
      QT_QAXSERVER_LIBRARY                The QAxServer library (Windows only)
      QT_QTCORE_LIBRARY                The QtCore library
      QT_QTDBUS_LIBRARY                The QtDBus library
      QT_QTDESIGNER_LIBRARY            The QtDesigner library
      QT_QTDESIGNERCOMPONENTS_LIBRARY  The QtDesignerComponents library
      QT_QTGUI_LIBRARY                 The QtGui library
      QT_QTMOTIF_LIBRARY               The QtMotif library
      QT_QTNETWORK_LIBRARY             The QtNetwork library
      QT_QTNSPLUGIN_LIBRARY            The QtNsPLugin library
      QT_QTOPENGL_LIBRARY              The QtOpenGL library
      QT_QTSQL_LIBRARY                 The QtSql library
      QT_QTXML_LIBRARY                 The QtXml library
      QT_QTSVG_LIBRARY                 The QtSvg library
      QT_QTSCRIPT_LIBRARY              The QtScript library
      QT_QTTEST_LIBRARY                The QtTest library
      QT_QTMAIN_LIBRARY                The qtmain library for Windows
      QT_QTUITOOLS_LIBRARY             The QtUiTools library
      QT_QTASSISTANTCLIENT_LIBRARY     The QtAssistantClient library
      QT_QTHELP_LIBRARY                The QtHelp library
      QT_QTWEBKIT_LIBRARY              The QtWebKit library
      QT_QTXMLPATTERNS_LIBRARY         The QtXmlPatterns library
      QT_PHONON_LIBRARY                The phonon library

    還有定義了，但「不」用於一般用途的是：

      QT_MOC_EXECUTABLE          Where to find the moc tool.
      QT_UIC_EXECUTABLE          Where to find the uic tool.
      QT_UIC3_EXECUTABLE         Where to find the uic3 tool.
      QT_RCC_EXECUTABLE          Where to find the rcc tool
      QT_DBUSCPP2XML_EXECUTABLE  Where to find the qdbuscpp2xml tool.
      QT_DBUSXML2CPP_EXECUTABLE  Where to find the qdbusxml2cpp tool.
      QT_LUPDATE_EXECUTABLE      Where to find the lupdate tool.
      QT_LRELEASE_EXECUTABLE     Where to find the lrelease tool.


    這些是為了向後相容性而保留，它們將會被設定。

      QT_WRAP_CPP  Set true if QT_MOC_EXECUTABLE is found
      QT_WRAP_UI   Set true if QT_UIC_EXECUTABLE is found

    這些變數「不再」有任何作用（與 FindQt.cmake 相比）。

      QT_MT_REQUIRED         Qt4 is now always multithreaded

    這些變數會設定為 ""，因為 Qt 結構已變更（它們在 Qt4 中沒有意義）。

      QT_QT_LIBRARY        Qt-Library is now split
  • FindQuickTime:

    尋找 QuickTime。此模組定義了 QUICKTIME_LIBRARY、QUICKTIME_FOUND (如果為 false，則不要嘗試連結到 gdal) 和 QUICKTIME_INCLUDE_DIR (用於尋找標頭檔)。

    $QUICKTIME_DIR 是一個環境變數，對應於 ./configure --prefix=$QUICKTIME_DIR。

    由 Eric Wing 建立。

  • FindRTI：嘗試尋找 M&S HLA RTI 函式庫

    此模組會尋找是否已安裝任何 HLA RTI，並尋找標準的 RTI 包含檔案和函式庫。

    RTI 是 IEEE 和 SISO 標準化的模擬基礎架構。它具有定義完善的 C++ API，可確保模擬應用程式獨立於特定的 RTI 實作。http://en.wikipedia.org/wiki/Run-Time_Infrastructure_(simulation)

    此程式碼會設定以下變數：

      RTI_INCLUDE_DIR = the directory where RTI includes file are found
      RTI_LIBRARIES = The libraries to link against to use RTI
      RTI_DEFINITIONS = -DRTI_USES_STD_FSTREAM
      RTI_FOUND = Set to FALSE if any HLA RTI was not found


    將問題報告給 <certi-devel@nongnu.org>。

  • FindRuby：尋找 Ruby

    此模組會尋找是否已安裝 Ruby，並確定標頭檔和函式庫的位置。它也會確定函式庫的名稱。此程式碼會設定以下變數：

      RUBY_INCLUDE_PATH = path to where ruby.h can be found
      RUBY_EXECUTABLE   = full path to the ruby binary
      RUBY_LIBRARY      = full path to the ruby library
  • FindSDL:

    尋找 SDL 函式庫。此模組定義了 SDL_LIBRARY (要連結的函式庫名稱)、SDL_FOUND (如果為 false，則不要嘗試連結到 SDL) 和 SDL_INCLUDE_DIR (用於尋找 SDL.h)。

    此模組會回應旗標：SDL_BUILDING_LIBRARY。如果已定義此旗標，則不會連結 SDL_main，因為只有應用程式需要 main()。否則，假設你正在建置應用程式，此模組會嘗試尋找並設定正確的連結旗標，作為傳回的 SDL_LIBRARY 變數的一部分。

    不要忘記在你的專案中包含 SDLmain.h 和 SDLmain.m，以取得 OS X 架構式版本。(其他版本會連結到 -lSDLmain，此模組會嘗試為你尋找。)此外，對於 OS X，此模組會自動為你新增 -framework Cocoa。


    額外注意事項：如果你在組態中看到空的 SDL_LIBRARY_TEMP 且沒有 SDL_LIBRARY，這表示 CMake 沒有找到你的 SDL 函式庫 (SDL.dll、libsdl.so、SDL.framework 等)。請將 SDL_LIBRARY_TEMP 設定為指向你的 SDL 函式庫，然後再次組態。同樣地，如果你看到空的 SDLMAIN_LIBRARY，則應根據需要設定此值。這些值用於產生最終的 SDL_LIBRARY 變數，但當這些值未設定時，不會建立 SDL_LIBRARY。


    $SDLDIR 是一個環境變數，對應於在建置 SDL 時使用的 ./configure --prefix=$SDLDIR。l.e.galup 9-20-02

    由 Eric Wing 修改。新增了程式碼，透過使用環境變數並提供更受控制/一致的搜尋行為來協助自動化建置。新增了新的修改，以辨識 OS X 架構和其他 Unix 路徑 (FreeBSD 等)。此外，更正了標頭搜尋路徑以遵循「正確的」SDL 指導方針。新增了對 SDLmain 的搜尋，這是某些平台所需要的。新增了對執行緒的搜尋，這是某些平台所需要的。新增了 MinGW 所需的編譯參數。

    在 OSX 上，這將優先選擇架構版本 (如果找到)，而非其他版本。人們必須手動變更 SDL_LIBRARY 的快取值，以覆寫此選取項目或設定 CMake 環境 CMAKE_INCLUDE_PATH 以修改搜尋路徑。

    請注意，標頭路徑已從 SDL/SDL.h 變更為僅 SDL.h。這需要變更，因為「正確的」SDL 慣例是 #include "SDL.h"，而不是 <SDL/SDL.h>。這樣做是為了可攜性，因為並非所有系統都將內容放在 SDL/ 中 (請參閱 FreeBSD)。

  • FindSDL_image:

    尋找 SDL_image 函式庫。此模組定義了 SDLIMAGE_LIBRARY (要連結的函式庫名稱)、SDLIMAGE_FOUND (如果為 false，則不要嘗試連結到 SDL) 和 SDLIMAGE_INCLUDE_DIR (用於尋找 SDL/SDL.h)。

    $SDLDIR 是一個環境變數，對應於在建置 SDL 時使用的 ./configure --prefix=$SDLDIR。

    由 Eric Wing 建立。這受到 FindSDL.cmake 模組的影響，但進行了修改以辨識 OS X 架構和其他 Unix 路徑 (FreeBSD 等)。

  • FindSDL_mixer:

    尋找 SDL_mixer 函式庫。此模組定義了 SDLMIXER_LIBRARY (要連結的函式庫名稱)、SDLMIXER_FOUND (如果為 false，則不要嘗試連結到 SDL) 和 SDLMIXER_INCLUDE_DIR (用於尋找 SDL/SDL.h)。

    $SDLDIR 是一個環境變數，對應於在建置 SDL 時使用的 ./configure --prefix=$SDLDIR。

    由 Eric Wing 建立。這受到 FindSDL.cmake 模組的影響，但進行了修改以辨識 OS X 架構和其他 Unix 路徑 (FreeBSD 等)。

  • FindSDL_net:

    尋找 SDL_net 函式庫。此模組定義了 SDLNET_LIBRARY (要連結的函式庫名稱)、SDLNET_FOUND (如果為 false，則不要嘗試連結到 SDL) 和 SDLNET_INCLUDE_DIR (用於尋找標頭檔)。

    $SDLDIR 是一個環境變數，對應於在建置 SDL 時使用的 ./configure --prefix=$SDLDIR。

    由 Eric Wing 建立。這受到 FindSDL.cmake 模組的影響，但進行了修改以辨識 OS X 架構和其他 Unix 路徑 (FreeBSD 等)。

  • FindSDL_sound:

    尋找 SDL_sound 函式庫。

  • FindSDL_ttf:

    尋找 SDL_ttf 函式庫。此模組定義了 SDLTTF_LIBRARY (要連結的函式庫名稱)、SDLTTF_FOUND (如果為 false，則不要嘗試連結到 SDL) 和 SDLTTF_INCLUDE_DIR (用於尋找 SDL/SDL.h)。

    $SDLDIR 是一個環境變數，對應於在建置 SDL 時使用的 ./configure --prefix=$SDLDIR。

    由 Eric Wing 建立。這受到 FindSDL.cmake 模組的影響，但進行了修改以辨識 OS X 架構和其他 Unix 路徑 (FreeBSD 等)。

  • FindSWIG：尋找 SWIG

    此模組會尋找已安裝的 SWIG。它會設定以下變數：

      SWIG_FOUND - set to true if SWIG is found
      SWIG_DIR - the directory where swig is installed
      SWIG_EXECUTABLE - the path to the swig executable
      SWIG_VERSION   - the version number of the swig executable


    所有資訊都是從 SWIG_EXECUTABLE 收集的，因此可以透過設定 SWIG_EXECUTABLE 從命令列變更要尋找的版本。

  • FindSelfPackers：尋找 upx

    此模組會尋找一些可執行檔封裝程式 (也就是將可執行檔或共用函式庫壓縮成即時自我解壓縮的可執行檔或共用函式庫的軟體)。範例：

      UPX: http://wildsau.idv.uni-linz.ac.at/mfx/upx.html
  • FindSquish：-- 一般使用


    此模組可用於尋找 Squish (目前支援的目標版本是 3)。

    SQUISH_FOUND (如果為 false，則不要嘗試使用 Squish) SQUISH_VERSION_MAJOR (找到的 Squish 主要版本) SQUISH_VERSION_MINOR (找到的 Squish 次要版本) SQUISH_VERSION_PATCH (找到的 Squish 修補版本)

    SQUISH_INSTALL_DIR (Squish 安裝目錄，包含 bin、lib 等) SQUISH_SERVER_EXECUTABLE (squishserver 可執行檔) SQUISH_CLIENT_EXECUTABLE (squishrunner 可執行檔)

    SQUISH_INSTALL_DIR_FOUND (是否找到安裝目錄？) SQUISH_SERVER_EXECUTABLE_FOUND (是否找到伺服器可執行檔？) SQUISH_CLIENT_EXECUTABLE_FOUND (是否找到用戶端可執行檔？)

    巨集 SQUISH_ADD_TEST(testName applicationUnderTest testSuite testCase)

    ENABLE_TESTING() FIND_PACKAGE(Squish) IF (SQUISH_FOUND)

       SQUISH_ADD_TEST(myTestName myApplication testSuiteName testCaseName)

    ENDIF (SQUISH_FOUND)

  • FindSubversion：從 Subversion 工作副本中擷取資訊

    該模組定義了以下變數

      Subversion_SVN_EXECUTABLE - path to svn command line client
      Subversion_VERSION_SVN - version of svn command line client
      Subversion_FOUND - true if the command line client was found

    如果找到命令列用戶端可執行檔，則會定義巨集

      Subversion_WC_INFO(<dir> <var-prefix>)

    以在給定位置擷取 Subversion 工作副本的資訊。此巨集會定義以下變數：

      <var-prefix>_WC_URL - url of the repository (at <dir>)
      <var-prefix>_WC_ROOT - root url of the repository
      <var-prefix>_WC_REVISION - current revision
      <var-prefix>_WC_LAST_CHANGED_AUTHOR - author of last commit
      <var-prefix>_WC_LAST_CHANGED_DATE - date of last commit
      <var-prefix>_WC_LAST_CHANGED_REV - revision of last commit
      <var-prefix>_WC_LAST_CHANGED_LOG - last log of base revision
      <var-prefix>_WC_INFO - output of command `svn info <dir>'

    使用範例

      FIND_PACKAGE(Subversion)
      IF(Subversion_FOUND)
        Subversion_WC_INFO(${PROJECT_SOURCE_DIR} Project)
        MESSAGE("Current revision is ${Project_WC_REVISION}")
        Subversion_WC_LOG(${PROJECT_SOURCE_DIR} Project)
        MESSAGE("Last changed log is ${Project_LAST_CHANGED_LOG}")
      ENDIF(Subversion_FOUND)
  • FindTCL：已移除 TK_INTERNAL_PATH。

    此模組會尋找是否已安裝 Tcl，並確定標頭檔和函式庫的位置。它也會確定函式庫的名稱。此程式碼會設定以下變數：

      TCL_FOUND              = Tcl was found
      TK_FOUND               = Tk was found
      TCLTK_FOUND            = Tcl and Tk were found
      TCL_LIBRARY            = path to Tcl library (tcl tcl80)
      TCL_INCLUDE_PATH       = path to where tcl.h can be found
      TCL_TCLSH              = path to tclsh binary (tcl tcl80)
      TK_LIBRARY             = path to Tk library (tk tk80 etc)
      TK_INCLUDE_PATH        = path to where tk.h can be found
      TK_WISH                = full path to the wish executable


    為了移除一些混亂，並為不一定是 Tcl/Tk 大師/開發人員的人員釐清一些問題，已移動或移除了一些變數。與 CMake 2.4 相比的變更如下：

       => they were only useful for people writing Tcl/Tk extensions.
       => these libs are not packaged by default with Tcl/Tk distributions. 
          Even when Tcl/Tk is built from source, several flavors of debug libs
          are created and there is no real reason to pick a single one
          specifically (say, amongst tcl84g, tcl84gs, or tcl84sgx). 
          Let's leave that choice to the user by allowing him to assign 
          TCL_LIBRARY to any Tcl library, debug or not.
       => this ended up being only a Win32 variable, and there is a lot of
          confusion regarding the location of this file in an installed Tcl/Tk
          tree anyway (see 8.5 for example). If you need the internal path at
          this point it is safer you ask directly where the *source* tree is
          and dig from there.
  • FindTIFF：尋找 TIFF 函式庫

    尋找原生 TIFF 包含檔案和函式庫。此模組會定義：

      TIFF_INCLUDE_DIR, where to find tiff.h, etc.
      TIFF_LIBRARIES, libraries to link against to use TIFF.
      TIFF_FOUND, If false, do not try to use TIFF.

    也定義了，但通常不使用

      TIFF_LIBRARY, where to find the TIFF library.
  • FindTclStub：已移除 TCL_STUB_LIBRARY_DEBUG 和 TK_STUB_LIBRARY_DEBUG。

    此模組會尋找 Tcl Stub 函式庫。它會先呼叫 FindTCL.cmake 來尋找 Tcl 包含檔案和函式庫。如何使用 Tcl Stub 函式庫

       http://tcl.activestate.com/doc/howto/stubs.html

    使用 Stub 函式庫

       http://safari.oreilly.com/0130385603/ch48lev1sec3

    此程式碼會設定以下變數：

      TCL_STUB_LIBRARY       = path to Tcl stub library
      TK_STUB_LIBRARY        = path to Tk stub library
      TTK_STUB_LIBRARY       = path to ttk stub library


    為了移除一些混亂，並為不一定是 Tcl/Tk 大師/開發人員的人員釐清一些問題，已移動或移除了一些變數。與 CMake 2.4 相比的變更如下：

       => these libs are not packaged by default with Tcl/Tk distributions. 
          Even when Tcl/Tk is built from source, several flavors of debug libs
          are created and there is no real reason to pick a single one
          specifically (say, amongst tclstub84g, tclstub84gs, or tclstub84sgx). 
          Let's leave that choice to the user by allowing him to assign 
          TCL_STUB_LIBRARY to any Tcl library, debug or not.
  • FindTclsh：尋找 tclsh

    這個模組會尋找是否已安裝 TCL，並判斷包含檔和程式庫的位置。它也會判斷程式庫的名稱。此程式碼會設定下列變數

      TCLSH_FOUND = TRUE if tclsh has been found
      TCL_TCLSH = the path to the tclsh executable

    在 cygwin 中，請先尋找 cygwin 版本。請勿稍後尋找它，以避免在 Win32 組建上找到 cygwin 版本。

  • FindThreads：此模組會判斷系統的執行緒程式庫。

    會設定以下變數

      CMAKE_THREAD_LIBS_INIT     - the thread library
      CMAKE_USE_SPROC_INIT       - are we using sproc?
      CMAKE_USE_WIN32_THREADS_INIT - using WIN32 threads?
      CMAKE_USE_PTHREADS_INIT    - are we using pthreads
      CMAKE_HP_PTHREADS_INIT     - are we using hp pthreads
  • FindUnixCommands：從 cygwin 尋找 unix 命令

    此模組會尋找一些常用的 Unix 命令。

  • FindVTK：尋找 VTK 安裝或組建樹狀結構。

    如果找到 VTK，則會設定下列變數。如果找不到 VTK，則 VTK_FOUND 會設為 false。

      VTK_FOUND         - Set to true when VTK is found.
      VTK_USE_FILE      - CMake file to use VTK.
      VTK_MAJOR_VERSION - The VTK major version number.
      VTK_MINOR_VERSION - The VTK minor version number 
                           (odd non-release).
      VTK_BUILD_VERSION - The VTK patch level 
                           (meaningless for odd minor).
      VTK_INCLUDE_DIRS  - Include directories for VTK
      VTK_LIBRARY_DIRS  - Link directories for VTK libraries
      VTK_KITS          - List of VTK kits, in CAPS 
                          (COMMON,IO,) etc.
      VTK_LANGUAGES     - List of wrapped languages, in CAPS
                          (TCL, PYHTON,) etc.

    使用者必須設定下列快取項目才能找到 VTK

      VTK_DIR  - The directory containing VTKConfig.cmake.  
                 This is either the root of the build tree,
                 or the lib/vtk directory.  This is the 
                 only cache entry.

    下列變數設定為向後相容性，不應在新程式碼中使用

      USE_VTK_FILE - The full path to the UseVTK.cmake file.
                     This is provided for backward 
                     compatibility.  Use VTK_USE_FILE 
                     instead.


  • FindWget：尋找 wget

    此模組會尋找 wget。此模組會定義下列值

      WGET_EXECUTABLE: the full path to the wget tool.
      WGET_FOUND: True if wget has been found.
  • FindWish：尋找 wish 安裝

    這個模組會尋找是否已安裝 TCL，並判斷包含檔和程式庫的位置。它也會判斷程式庫的名稱。此程式碼會設定下列變數

      TK_WISH = the path to the wish executable


    如果定義了 UNIX，則會先尋找 cygwin 版本

  • FindX11：尋找 X11 安裝

    嘗試在 UNIX 系統上尋找 X11。會定義下列值

      X11_FOUND        - True if X11 is available
      X11_INCLUDE_DIR  - include directories to use X11
      X11_LIBRARIES    - link against these to use X11


    還有下列更精細的變數：包含路徑：X11_ICE_INCLUDE_PATH、X11_ICE_LIB、X11_ICE_FOUND

                    X11_Xaccessrules_INCLUDE_PATH,                     X11_Xaccess_FOUND
                    X11_Xaccessstr_INCLUDE_PATH,                       X11_Xaccess_FOUND
                    X11_Xau_INCLUDE_PATH,          X11_Xau_LIB,        X11_Xau_FOUND
                    X11_Xcomposite_INCLUDE_PATH,   X11_Xcomposite_LIB, X11_Xcomposite_FOUND
                    X11_Xcursor_INCLUDE_PATH,      X11_Xcursor_LIB,    X11_Xcursor_FOUND
                    X11_Xdamage_INCLUDE_PATH,      X11_Xdamage_LIB,    X11_Xdamage_FOUND
                    X11_Xdmcp_INCLUDE_PATH,        X11_Xdmcp_LIB,      X11_Xdmcp_FOUND
                                                   X11_Xext_LIB,       X11_Xext_FOUND
                    X11_dpms_INCLUDE_PATH,         (in X11_Xext_LIB),  X11_dpms_FOUND
                    X11_XShm_INCLUDE_PATH,         (in X11_Xext_LIB),  X11_XShm_FOUND
                    X11_Xshape_INCLUDE_PATH,       (in X11_Xext_LIB),  X11_Xshape_FOUND
                    X11_xf86misc_INCLUDE_PATH,     X11_Xxf86misc_LIB,  X11_xf86misc_FOUND
                    X11_xf86vmode_INCLUDE_PATH,                        X11_xf86vmode_FOUND
                    X11_Xfixes_INCLUDE_PATH,       X11_Xfixes_LIB,     X11_Xfixes_FOUND
                    X11_Xft_INCLUDE_PATH,          X11_Xft_LIB,        X11_Xft_FOUND
                    X11_Xinerama_INCLUDE_PATH,     X11_Xinerama_LIB,   X11_Xinerama_FOUND
                    X11_Xinput_INCLUDE_PATH,       X11_Xinput_LIB,     X11_Xinput_FOUND
                    X11_Xkb_INCLUDE_PATH,                              X11_Xkb_FOUND
                    X11_Xkblib_INCLUDE_PATH,                           X11_Xkb_FOUND
                    X11_Xpm_INCLUDE_PATH,          X11_Xpm_LIB,        X11_Xpm_FOUND
                    X11_XTest_INCLUDE_PATH,        X11_XTest_LIB,      X11_XTest_FOUND
                    X11_Xrandr_INCLUDE_PATH,       X11_Xrandr_LIB,     X11_Xrandr_FOUND
                    X11_Xrender_INCLUDE_PATH,      X11_Xrender_LIB,    X11_Xrender_FOUND
                    X11_Xscreensaver_INCLUDE_PATH, X11_Xscreensaver_LIB, X11_Xscreensaver_FOUND
                    X11_Xt_INCLUDE_PATH,           X11_Xt_LIB,         X11_Xt_FOUND
                    X11_Xutil_INCLUDE_PATH,                            X11_Xutil_FOUND
                    X11_Xv_INCLUDE_PATH,           X11_Xv_LIB,         X11_Xv_FOUND
  • FindXMLRPC：尋找 xmlrpc

    尋找原生 XMLRPC 標頭和程式庫。

      XMLRPC_INCLUDE_DIRS      - where to find xmlrpc.h, etc.
      XMLRPC_LIBRARIES         - List of libraries when using xmlrpc.
      XMLRPC_FOUND             - True if xmlrpc found.

    XMLRPC 模組可以指定為此尋找模組的元件。可以執行 "xmlrpc-c-config" 來列出模組。模組包括

      c++            C++ wrapper code
      libwww-client  libwww-based client
      cgi-server     CGI-based server
      abyss-server   ABYSS-based server

    典型用法

      FIND_PACKAGE(XMLRPC REQUIRED libwww-client)
  • FindZLIB：尋找 zlib

    尋找原生 ZLIB 包含和程式庫

      ZLIB_INCLUDE_DIR - where to find zlib.h, etc.
      ZLIB_LIBRARIES   - List of libraries when using zlib.
      ZLIB_FOUND       - True if zlib found.
  • Findosg:


    注意：強烈建議您使用 CMake 2.6.3 中引入的新 FindOpenSceneGraph.cmake，而不要直接使用此 Find 模組。

    這是 Findosg* 套件的一部分，用於尋找 OpenSceneGraph 元件。每個元件都是獨立的，您必須選擇加入每個模組。您也必須選擇加入 OpenGL 和 OpenThreads（如果需要，還需加入 Producer），因為這些模組不會為您執行此操作。這是為了讓您能夠逐個控制自己的系統，以防您需要選擇退出某些元件，或變更特定模組的 Find 行為（例如，因為預設的 FindOpenGL.cmake 模組無法與您的系統搭配使用）。如果您想使用包含所有內容的更方便模組，請使用 FindOpenSceneGraph.cmake 而不是 Findosg*.cmake 模組。

    找到 osg 這個模組定義

    OSG_FOUND - 是否找到 Osg？OSG_INCLUDE_DIR - 在哪裡找到標頭？OSG_LIBRARIES - 要針對 OSG 連結的程式庫 (使用此項)

    OSG_LIBRARY - OSG 程式庫 OSG_LIBRARY_DEBUG - OSG 偵錯程式庫

    $OSGDIR 是環境變數，對應於建置 osg 時使用的 ./configure --prefix=$OSGDIR。

    由 Eric Wing 建立。

  • FindosgAnimation:

    這是 Findosg* 套件的一部分，用於尋找 OpenSceneGraph 元件。每個元件都是獨立的，您必須選擇加入每個模組。您也必須選擇加入 OpenGL 和 OpenThreads（如果需要，還需加入 Producer），因為這些模組不會為您執行此操作。這是為了讓您能夠逐個控制自己的系統，以防您需要選擇退出某些元件，或變更特定模組的 Find 行為（例如，因為預設的 FindOpenGL.cmake 模組無法與您的系統搭配使用）。如果您想使用包含所有內容的更方便模組，請使用 FindOpenSceneGraph.cmake 而不是 Findosg*.cmake 模組。

    找到 osgAnimation 這個模組定義

    OSGANIMATION_FOUND - 是否找到 osgAnimation？OSGANIMATION_INCLUDE_DIR - 在哪裡找到標頭？OSGANIMATION_LIBRARIES - 要針對 OSG 連結的程式庫 (使用此項)

    OSGANIMATION_LIBRARY - OSG 程式庫 OSGANIMATION_LIBRARY_DEBUG - OSG 偵錯程式庫

    $OSGDIR 是環境變數，對應於建置 osg 時使用的 ./configure --prefix=$OSGDIR。

    由 Eric Wing 建立。

  • FindosgDB:

    這是 Findosg* 套件的一部分，用於尋找 OpenSceneGraph 元件。每個元件都是獨立的，您必須選擇加入每個模組。您也必須選擇加入 OpenGL 和 OpenThreads（如果需要，還需加入 Producer），因為這些模組不會為您執行此操作。這是為了讓您能夠逐個控制自己的系統，以防您需要選擇退出某些元件，或變更特定模組的 Find 行為（例如，因為預設的 FindOpenGL.cmake 模組無法與您的系統搭配使用）。如果您想使用包含所有內容的更方便模組，請使用 FindOpenSceneGraph.cmake 而不是 Findosg*.cmake 模組。

    找到 osgDB 這個模組定義

    OSGDB_FOUND - 是否找到 osgDB？OSGDB_INCLUDE_DIR - 在哪裡找到標頭？OSGDB_LIBRARIES - 要針對 osgDB 連結的程式庫 (使用此項)

    OSGDB_LIBRARY - osgDB 程式庫 OSGDB_LIBRARY_DEBUG - osgDB 偵錯程式庫

    $OSGDIR 是環境變數，對應於建置 osg 時使用的 ./configure --prefix=$OSGDIR。

    由 Eric Wing 建立。

  • FindosgFX:

    這是 Findosg* 套件的一部分，用於尋找 OpenSceneGraph 元件。每個元件都是獨立的，您必須選擇加入每個模組。您也必須選擇加入 OpenGL 和 OpenThreads（如果需要，還需加入 Producer），因為這些模組不會為您執行此操作。這是為了讓您能夠逐個控制自己的系統，以防您需要選擇退出某些元件，或變更特定模組的 Find 行為（例如，因為預設的 FindOpenGL.cmake 模組無法與您的系統搭配使用）。如果您想使用包含所有內容的更方便模組，請使用 FindOpenSceneGraph.cmake 而不是 Findosg*.cmake 模組。

    找到 osgFX 這個模組定義

    OSGFX_FOUND - 是否找到 osgFX？OSGFX_INCLUDE_DIR - 在哪裡找到標頭？OSGFX_LIBRARIES - 要針對 osgFX 連結的程式庫 (使用此項)

    OSGFX_LIBRARY - osgFX 程式庫 OSGFX_LIBRARY_DEBUG - osgFX 偵錯程式庫

    $OSGDIR 是環境變數，對應於建置 osg 時使用的 ./configure --prefix=$OSGDIR。

    由 Eric Wing 建立。

  • FindosgGA:

    這是 Findosg* 套件的一部分，用於尋找 OpenSceneGraph 元件。每個元件都是獨立的，您必須選擇加入每個模組。您也必須選擇加入 OpenGL 和 OpenThreads（如果需要，還需加入 Producer），因為這些模組不會為您執行此操作。這是為了讓您能夠逐個控制自己的系統，以防您需要選擇退出某些元件，或變更特定模組的 Find 行為（例如，因為預設的 FindOpenGL.cmake 模組無法與您的系統搭配使用）。如果您想使用包含所有內容的更方便模組，請使用 FindOpenSceneGraph.cmake 而不是 Findosg*.cmake 模組。

    找到 osgGA 這個模組定義

    OSGGA_FOUND - 是否找到 osgGA？OSGGA_INCLUDE_DIR - 在哪裡找到標頭？OSGGA_LIBRARIES - 要針對 osgGA 連結的程式庫 (使用此項)

    OSGGA_LIBRARY - osgGA 程式庫 OSGGA_LIBRARY_DEBUG - osgGA 偵錯程式庫

    $OSGDIR 是環境變數，對應於建置 osg 時使用的 ./configure --prefix=$OSGDIR。

    由 Eric Wing 建立。

  • FindosgIntrospection:

    這是 Findosg* 套件的一部分，用於尋找 OpenSceneGraph 元件。每個元件都是獨立的，您必須選擇加入每個模組。您也必須選擇加入 OpenGL 和 OpenThreads（如果需要，還需加入 Producer），因為這些模組不會為您執行此操作。這是為了讓您能夠逐個控制自己的系統，以防您需要選擇退出某些元件，或變更特定模組的 Find 行為（例如，因為預設的 FindOpenGL.cmake 模組無法與您的系統搭配使用）。如果您想使用包含所有內容的更方便模組，請使用 FindOpenSceneGraph.cmake 而不是 Findosg*.cmake 模組。

    找到 osgINTROSPECTION 這個模組定義

    OSGINTROSPECTION_FOUND - 是否找到 osgIntrospection？OSGINTROSPECTION_INCLUDE_DIR - 在哪裡找到標頭？OSGINTROSPECTION_LIBRARIES - 要針對 osgIntrospection 連結的程式庫 (使用此項)

    OSGINTROSPECTION_LIBRARY - osgIntrospection 程式庫 OSGINTROSPECTION_LIBRARY_DEBUG - osgIntrospection 偵錯程式庫

    $OSGDIR 是環境變數，對應於建置 osg 時使用的 ./configure --prefix=$OSGDIR。

    由 Eric Wing 建立。

  • FindosgManipulator:

    這是 Findosg* 套件的一部分，用於尋找 OpenSceneGraph 元件。每個元件都是獨立的，您必須選擇加入每個模組。您也必須選擇加入 OpenGL 和 OpenThreads（如果需要，還需加入 Producer），因為這些模組不會為您執行此操作。這是為了讓您能夠逐個控制自己的系統，以防您需要選擇退出某些元件，或變更特定模組的 Find 行為（例如，因為預設的 FindOpenGL.cmake 模組無法與您的系統搭配使用）。如果您想使用包含所有內容的更方便模組，請使用 FindOpenSceneGraph.cmake 而不是 Findosg*.cmake 模組。

    找到 osgManipulator 這個模組定義

    OSGMANIPULATOR_FOUND - 是否找到 osgManipulator？OSGMANIPULATOR_INCLUDE_DIR - 在哪裡找到標頭？OSGMANIPULATOR_LIBRARIES - 要針對 osgManipulator 連結的程式庫 (使用此項)

    OSGMANIPULATOR_LIBRARY - osgManipulator 程式庫 OSGMANIPULATOR_LIBRARY_DEBUG - osgManipulator 偵錯程式庫

    $OSGDIR 是環境變數，對應於建置 osg 時使用的 ./configure --prefix=$OSGDIR。

    由 Eric Wing 建立。

  • FindosgParticle:

    這是 Findosg* 套件的一部分，用於尋找 OpenSceneGraph 元件。每個元件都是獨立的，您必須選擇加入每個模組。您也必須選擇加入 OpenGL 和 OpenThreads（如果需要，還需加入 Producer），因為這些模組不會為您執行此操作。這是為了讓您能夠逐個控制自己的系統，以防您需要選擇退出某些元件，或變更特定模組的 Find 行為（例如，因為預設的 FindOpenGL.cmake 模組無法與您的系統搭配使用）。如果您想使用包含所有內容的更方便模組，請使用 FindOpenSceneGraph.cmake 而不是 Findosg*.cmake 模組。

    找到 osgParticle 這個模組定義

    OSGPARTICLE_FOUND - 是否找到 osgParticle？OSGPARTICLE_INCLUDE_DIR - 在哪裡找到標頭？OSGPARTICLE_LIBRARIES - 要針對 osgParticle 連結的程式庫 (使用此項)

    OSGPARTICLE_LIBRARY - osgParticle 程式庫 OSGPARTICLE_LIBRARY_DEBUG - osgParticle 偵錯程式庫

    $OSGDIR 是環境變數，對應於建置 osg 時使用的 ./configure --prefix=$OSGDIR。

    由 Eric Wing 建立。

  • FindosgProducer:

    這是 Findosg* 套件的一部分，用於尋找 OpenSceneGraph 元件。每個元件都是獨立的，您必須選擇加入每個模組。您也必須選擇加入 OpenGL 和 OpenThreads（如果需要，還需加入 Producer），因為這些模組不會為您執行此操作。這是為了讓您能夠逐個控制自己的系統，以防您需要選擇退出某些元件，或變更特定模組的 Find 行為（例如，因為預設的 FindOpenGL.cmake 模組無法與您的系統搭配使用）。如果您想使用包含所有內容的更方便模組，請使用 FindOpenSceneGraph.cmake 而不是 Findosg*.cmake 模組。

    找到 osgProducer 這個模組定義

    OSGPRODUCER_FOUND - 是否找到 osgProducer？OSGPRODUCER_INCLUDE_DIR - 在哪裡找到標頭？OSGPRODUCER_LIBRARIES - 要針對 osgProducer 連結的程式庫 (使用此項)

    OSGPRODUCER_LIBRARY - osgProducer 程式庫 OSGPRODUCER_LIBRARY_DEBUG - osgProducer 偵錯程式庫

    $OSGDIR 是環境變數，對應於建置 osg 時使用的 ./configure --prefix=$OSGDIR。

    由 Eric Wing 建立。

  • FindosgShadow:

    這是 Findosg* 套件的一部分，用於尋找 OpenSceneGraph 元件。每個元件都是獨立的，您必須選擇加入每個模組。您也必須選擇加入 OpenGL 和 OpenThreads（如果需要，還需加入 Producer），因為這些模組不會為您執行此操作。這是為了讓您能夠逐個控制自己的系統，以防您需要選擇退出某些元件，或變更特定模組的 Find 行為（例如，因為預設的 FindOpenGL.cmake 模組無法與您的系統搭配使用）。如果您想使用包含所有內容的更方便模組，請使用 FindOpenSceneGraph.cmake 而不是 Findosg*.cmake 模組。

    找到 osgShadow 這個模組定義

    OSGSHADOW_FOUND - 是否找到 osgShadow？OSGSHADOW_INCLUDE_DIR - 在哪裡找到標頭？OSGSHADOW_LIBRARIES - 要針對 osgShadow 連結的程式庫 (使用此項)

    OSGSHADOW_LIBRARY - osgShadow 程式庫 OSGSHADOW_LIBRARY_DEBUG - osgShadow 偵錯程式庫

    $OSGDIR 是環境變數，對應於建置 osg 時使用的 ./configure --prefix=$OSGDIR。

    由 Eric Wing 建立。

  • FindosgSim:

    這是 Findosg* 套件的一部分，用於尋找 OpenSceneGraph 元件。每個元件都是獨立的，您必須選擇加入每個模組。您也必須選擇加入 OpenGL 和 OpenThreads（如果需要，還需加入 Producer），因為這些模組不會為您執行此操作。這是為了讓您能夠逐個控制自己的系統，以防您需要選擇退出某些元件，或變更特定模組的 Find 行為（例如，因為預設的 FindOpenGL.cmake 模組無法與您的系統搭配使用）。如果您想使用包含所有內容的更方便模組，請使用 FindOpenSceneGraph.cmake 而不是 Findosg*.cmake 模組。

    找到 osgSim 這個模組定義

    OSGSIM_FOUND - 是否找到 osgSim？OSGSIM_INCLUDE_DIR - 在哪裡找到標頭？OSGSIM_LIBRARIES - 要針對 osgSim 連結的程式庫 (使用此項)

    OSGSIM_LIBRARY - osgSim 程式庫 OSGSIM_LIBRARY_DEBUG - osgSim 偵錯程式庫

    $OSGDIR 是環境變數，對應於建置 osg 時使用的 ./configure --prefix=$OSGDIR。

    由 Eric Wing 建立。

  • FindosgTerrain:

    這是 Findosg* 套件的一部分，用於尋找 OpenSceneGraph 元件。每個元件都是獨立的，您必須選擇加入每個模組。您也必須選擇加入 OpenGL 和 OpenThreads（如果需要，還需加入 Producer），因為這些模組不會為您執行此操作。這是為了讓您能夠逐個控制自己的系統，以防您需要選擇退出某些元件，或變更特定模組的 Find 行為（例如，因為預設的 FindOpenGL.cmake 模組無法與您的系統搭配使用）。如果您想使用包含所有內容的更方便模組，請使用 FindOpenSceneGraph.cmake 而不是 Findosg*.cmake 模組。

    找到 osgTerrain 這個模組定義

    OSGTERRAIN_FOUND - 是否找到 osgTerrain？OSGTERRAIN_INCLUDE_DIR - 在哪裡找到標頭？OSGTERRAIN_LIBRARIES - 要針對 osgTerrain 連結的程式庫 (使用此項)

    OSGTERRAIN_LIBRARY - osgTerrain 程式庫 OSGTERRAIN_LIBRARY_DEBUG - osgTerrain 偵錯程式庫

    $OSGDIR 是環境變數，對應於建置 osg 時使用的 ./configure --prefix=$OSGDIR。

    由 Eric Wing 建立。

  • FindosgText:

    這是 Findosg* 套件的一部分，用於尋找 OpenSceneGraph 元件。每個元件都是獨立的，您必須選擇加入每個模組。您也必須選擇加入 OpenGL 和 OpenThreads（如果需要，還需加入 Producer），因為這些模組不會為您執行此操作。這是為了讓您能夠逐個控制自己的系統，以防您需要選擇退出某些元件，或變更特定模組的 Find 行為（例如，因為預設的 FindOpenGL.cmake 模組無法與您的系統搭配使用）。如果您想使用包含所有內容的更方便模組，請使用 FindOpenSceneGraph.cmake 而不是 Findosg*.cmake 模組。

    找到 osgText 這個模組定義

    OSGTEXT_FOUND - 是否找到 osgText？OSGTEXT_INCLUDE_DIR - 在哪裡找到標頭？OSGTEXT_LIBRARIES - 要針對 osgText 連結的程式庫 (使用此項)

    OSGTEXT_LIBRARY - osgText 程式庫 OSGTEXT_LIBRARY_DEBUG - osgText 偵錯程式庫

    $OSGDIR 是環境變數，對應於建置 osg 時使用的 ./configure --prefix=$OSGDIR。

    由 Eric Wing 建立。

  • FindosgUtil:

    這是 Findosg* 套件的一部分，用於尋找 OpenSceneGraph 元件。每個元件都是獨立的，您必須選擇加入每個模組。您也必須選擇加入 OpenGL 和 OpenThreads（如果需要，還需加入 Producer），因為這些模組不會為您執行此操作。這是為了讓您能夠逐個控制自己的系統，以防您需要選擇退出某些元件，或變更特定模組的 Find 行為（例如，因為預設的 FindOpenGL.cmake 模組無法與您的系統搭配使用）。如果您想使用包含所有內容的更方便模組，請使用 FindOpenSceneGraph.cmake 而不是 Findosg*.cmake 模組。

    找到 osgUtil 這個模組定義

    OSGUTIL_FOUND - 是否找到 osgUtil？OSGUTIL_INCLUDE_DIR - 在哪裡找到標頭？OSGUTIL_LIBRARIES - 要針對 osgUtil 連結的程式庫 (使用此項)

    OSGUTIL_LIBRARY - osgUtil 程式庫 OSGUTIL_LIBRARY_DEBUG - osgUtil 偵錯程式庫

    $OSGDIR 是環境變數，對應於建置 osg 時使用的 ./configure --prefix=$OSGDIR。

    由 Eric Wing 建立。

  • FindosgViewer:

    這是 Findosg* 套件的一部分，用於尋找 OpenSceneGraph 元件。每個元件都是獨立的，您必須選擇加入每個模組。您也必須選擇加入 OpenGL 和 OpenThreads（如果需要，還需加入 Producer），因為這些模組不會為您執行此操作。這是為了讓您能夠逐個控制自己的系統，以防您需要選擇退出某些元件，或變更特定模組的 Find 行為（例如，因為預設的 FindOpenGL.cmake 模組無法與您的系統搭配使用）。如果您想使用包含所有內容的更方便模組，請使用 FindOpenSceneGraph.cmake 而不是 Findosg*.cmake 模組。

    找到 osgViewer 這個模組定義

    OSGVIEWER_FOUND - 是否找到 osgViewer？OSGVIEWER_INCLUDE_DIR - 在哪裡找到標頭？OSGVIEWER_LIBRARIES - 要針對 osgViewer 連結的程式庫 (使用此項)

    OSGVIEWER_LIBRARY - osgViewer 程式庫 OSGVIEWER_LIBRARY_DEBUG - osgViewer 偵錯程式庫

    $OSGDIR 是環境變數，對應於建置 osg 時使用的 ./configure --prefix=$OSGDIR。

    由 Eric Wing 建立。

  • FindosgVolume:

    這是 Findosg* 套件的一部分，用於尋找 OpenSceneGraph 元件。每個元件都是獨立的，您必須選擇加入每個模組。您也必須選擇加入 OpenGL 和 OpenThreads（如果需要，還需加入 Producer），因為這些模組不會為您執行此操作。這是為了讓您能夠逐個控制自己的系統，以防您需要選擇退出某些元件，或變更特定模組的 Find 行為（例如，因為預設的 FindOpenGL.cmake 模組無法與您的系統搭配使用）。如果您想使用包含所有內容的更方便模組，請使用 FindOpenSceneGraph.cmake 而不是 Findosg*.cmake 模組。

    找到 osgVolume 這個模組定義

    OSGVOLUME_FOUND - 是否找到 osgVolume？OSGVOLUME_INCLUDE_DIR - 在哪裡找到標頭？OSGVOLUME_LIBRARIES - 要針對 osgVolume 連結的程式庫 (使用此項)

    OSGVOLUME_LIBRARY - osgVolume 程式庫 OSGVOLUME_LIBRARY_DEBUG - osgVolume 偵錯程式庫

    $OSGDIR 是環境變數，對應於建置 osg 時使用的 ./configure --prefix=$OSGDIR。

    由 Eric Wing 建立。

  • FindosgWidget:

    這是 Findosg* 套件的一部分，用於尋找 OpenSceneGraph 元件。每個元件都是獨立的，您必須選擇加入每個模組。您也必須選擇加入 OpenGL 和 OpenThreads（如果需要，還需加入 Producer），因為這些模組不會為您執行此操作。這是為了讓您能夠逐個控制自己的系統，以防您需要選擇退出某些元件，或變更特定模組的 Find 行為（例如，因為預設的 FindOpenGL.cmake 模組無法與您的系統搭配使用）。如果您想使用包含所有內容的更方便模組，請使用 FindOpenSceneGraph.cmake 而不是 Findosg*.cmake 模組。

    找到 osgWidget 這個模組定義

    OSGWIDGET_FOUND - 是否找到 osgWidget？OSGWIDGET_INCLUDE_DIR - 在哪裡找到標頭？OSGWIDGET_LIBRARIES - 要針對 osgWidget 連結的程式庫 (使用此項)

    OSGWIDGET_LIBRARY - osgWidget 程式庫 OSGWIDGET_LIBRARY_DEBUG - osgWidget 偵錯程式庫

    $OSGDIR 是環境變數，對應於建置 osg 時使用的 ./configure --prefix=$OSGDIR。

    FindosgWidget.cmake 是從 Eric Wing 建立的 Findosg* 套件調整而來。

  • Findosg_functions:


    這個 CMake 檔案包含兩個巨集，可協助搜尋 OSG 程式庫和節點套件。

  • FindwxWidgets：尋找 wxWidgets（又稱 wxWindows）安裝。

    此模組會尋找是否已安裝 wxWidgets，並選取要使用的預設組態。wxWidgets 是模組化程式庫。若要指定您將使用的模組，您需要將它們命名為套件的元件

    FIND_PACKAGE(wxWidgets COMPONENTS base core ...)

    有兩個搜尋分支：windows 樣式和 unix 樣式。對於 windows，會搜尋下列變數，並在有多個選項時設定為預設值。如果不需要預設值，請變更它們 (也就是說，這些是您應該變更以選取組態的唯一變數)

      wxWidgets_ROOT_DIR      - Base wxWidgets directory
                                (e.g., C:/wxWidgets-2.6.3).
      wxWidgets_LIB_DIR       - Path to wxWidgets libraries
                                (e.g., C:/wxWidgets-2.6.3/lib/vc_lib).
      wxWidgets_CONFIGURATION - Configuration to use
                                (e.g., msw, mswd, mswu, mswunivud, etc.)


    對於 unix 樣式，它會使用 wx-config 公用程式。您可以透過在 QtDialog 或 ccmake 介面中開啟/關閉下列變數，來選取偵錯/發行、unicode/ansi、universal/non-universal 和靜態/共用

      wxWidgets_USE_DEBUG
      wxWidgets_USE_UNICODE
      wxWidgets_USE_UNIVERSAL
      wxWidgets_USE_STATIC

    在完成 windows 和 unix 樣式的組態後，會設定下列項目

      wxWidgets_FOUND            - Set to TRUE if wxWidgets was found.
      wxWidgets_INCLUDE_DIRS     - Include directories for WIN32
                                   i.e., where to find "wx/wx.h" and
                                   "wx/setup.h"; possibly empty for unices.
      wxWidgets_LIBRARIES        - Path to the wxWidgets libraries.
      wxWidgets_LIBRARY_DIRS     - compile time link dirs, useful for
                                   rpath on UNIX. Typically an empty string
                                   in WIN32 environment.
      wxWidgets_DEFINITIONS      - Contains defines required to compile/link
                                   against WX, e.g. -DWXUSINGDLL
      wxWidgets_CXX_FLAGS        - Include dirs and ompiler flags for
                                   unices, empty on WIN32. Esentially
                                   "`wx-config --cxxflags`".
      wxWidgets_USE_FILE         - Convenience include file.


    範例用法

       FIND_PACKAGE(wxWidgets COMPONENTS base core gl net)
       IF(wxWidgets_FOUND)
         INCLUDE(${wxWidgets_USE_FILE})
         # and for each of your dependant executable/library targets:
         TARGET_LINK_LIBRARIES(<YourTarget> ${wxWidgets_LIBRARIES})
       ENDIF(wxWidgets_FOUND)


    如果需要 wxWidgets (也就是說，不是選擇性部分)

       FIND_PACKAGE(wxWidgets REQUIRED base core gl net)
       INCLUDE(${wxWidgets_USE_FILE})
       # and for each of your dependant executable/library targets:
       TARGET_LINK_LIBRARIES(<YourTarget> ${wxWidgets_LIBRARIES})
  • FindwxWindows：尋找 wxWindows (wxWidgets) 安裝

    此模組會尋找是否已安裝 wxWindows/wxWidgets，並判斷包含檔和程式庫的位置。它也會判斷程式庫的名稱。請注意，此檔案已過時，並由 FindwxWidgets.cmake 取代。此程式碼會設定下列變數

      WXWINDOWS_FOUND     = system has WxWindows
      WXWINDOWS_LIBRARIES = path to the wxWindows libraries
                            on Unix/Linux with additional
                            linker flags from
                            "wx-config --libs"
      CMAKE_WXWINDOWS_CXX_FLAGS  = Compiler flags for wxWindows,
                                   essentially "`wx-config --cxxflags`"
                                   on Linux
      WXWINDOWS_INCLUDE_DIR      = where to find "wx/wx.h" and "wx/setup.h"
      WXWINDOWS_LINK_DIRECTORIES = link directories, useful for rpath on
                                    Unix
      WXWINDOWS_DEFINITIONS      = extra defines


    選項 如果您需要 OpenGL 支援，請

      SET(WXWINDOWS_USE_GL 1)

    在您的 CMakeLists.txt 中 *在* 您包含此檔案之前。

      HAVE_ISYSTEM      - true required to replace -I by -isystem on g++


    為了方便起見，請使用 INCLUDE(Use_wxWindows) 在專案的 CMakeLists.txt 中包含 Use_wxWindows.cmake。

    用法

      SET(WXWINDOWS_USE_GL 1)
      FIND_PACKAGE(wxWindows)


    注意事項 wxWidgets 2.6.x 支援單體建置，例如在 wx/build/msw 目錄中編譯為

      nmake -f makefile.vc BUILD=debug SHARED=0 USE_OPENGL=1 MONOLITHIC=1


    已過時

      CMAKE_WX_CAN_COMPILE
      WXWINDOWS_LIBRARY
      CMAKE_WX_CXX_FLAGS
      WXWINDOWS_INCLUDE_PATH


    作者 Jan Woetzel <http://www.mip.informatik.uni-kiel.de/~jw> (07/2003-01/2006)

  • FortranCInterface:

    FortranCInterface.cmake

    此檔案定義函式 create_fortran_c_interface。此函式用於建立已設定的標頭檔，其中包含從 C 到 Fortran 函式的對應，使用目前 Fortran 編譯器定義的正確名稱修飾配置。

    此函式會記錄要設定的函式清單和標頭檔的名稱。

    此檔案也會定義一些輔助函式，這些函式用於偵測目前 Fortran 編譯器使用的 Fortran 名稱修飾配置。

      test_fortran_mangling - test a single fortran mangling 
      discover_fortran_mangling - loop over all combos of fortran
       name mangling and call test_fortran_mangling until one of them
       works.
      discover_fortran_module_mangling - try different types of 
      fortran modle name mangling to find one that works




    此函式會測試單一的 fortran 修飾。CODE - 要嘗試的測試程式碼應定義名為 "sub" 的副程式 PREFIX - 放在 sub 前面的字串 POSTFIX - 放在 sub 後面的字串 ISUPPER - 如果為 TRUE，則 sub 將以 SUB 呼叫 DOC - 用於狀態檢查的字串 Fortran ${DOC} 連結 SUB - 要呼叫的 SUB 名稱 RESULT 儲存結果的位置 如果此連結有效，則為 TRUE，否則為 FALSE

            if not.


  • GetPrerequisites:

    GetPrerequisites.cmake

    此指令碼提供函式來列出可執行檔或共用程式庫檔案所相依的 .dll、.dylib 或 .so 檔案。(其必要條件。)

    它使用各種工具來取得所需共用程式庫檔案的清單

       dumpbin (Windows)
       ldd (Linux/Unix)
       otool (Mac OSX)


    此腳本提供以下函式

       gp_append_unique
       gp_file_type
       is_file_executable
       gp_item_default_embedded_path
         (projects can override with gp_item_default_embedded_path_override)
       gp_resolve_item
         (projects can override with gp_resolve_item_override)
       get_prerequisites
       list_prerequisites
       list_prerequisites_by_glob


    需要 CMake 2.6 或更新版本，因為它使用函式、中斷、傳回和 PARENT_SCOPE。

  • ITKCompatibility:

    解決 ITK 3.0 版之前的舊錯誤

  • InstallRequiredSystemLibraries:

    透過包含此檔案，CMAKE_INSTALL_DEBUG_LIBRARIES 中的所有檔案都會與 INSTALL_PROGRAMS 一起安裝到 WIN32 的 /bin 和非 win32 的 /lib。如果在包含此檔案之前將 CMAKE_SKIP_INSTALL_RULES 設定為 TRUE，則不會呼叫 INSTALL 命令。使用者可以使用變數 CMAKE_INSTALL_SYSTEM_RUNTIME_LIBS 來使用自訂安裝命令，並將它們安裝到他們想要的任何目錄。如果是 MSVC 編譯器，則會找到 microsoft 執行階段程式庫，並自動新增至 CMAKE_INSTALL_DEBUG_LIBRARIES 並安裝。如果設定了 CMAKE_INSTALL_DEBUG_LIBRARIES 且它是 MSVC 編譯器，則偵錯程式庫會在可用時安裝。如果設定了 CMAKE_INSTALL_MFC_LIBRARIES，則會安裝 MFC 執行階段程式庫以及 CRT 執行階段程式庫。

  • MacroAddFileDependencies：MACRO_ADD_FILE_DEPENDENCIES(<_file> depend_files...)

    MACRO_OPTIONAL_FIND_PACKAGE( <name> [QUIT] )

  • SquishTestScript:


    這個腳本使用 Squish 啟動 GUI 測試。您不應該直接呼叫此腳本；相反地，您應該透過 FindSquish.cmake 中定義的 SQUISH_ADD_TEST 巨集來存取它。

    這個腳本會啟動 Squish 伺服器、在客戶端上啟動測試，最後停止 squish 伺服器。如果這些步驟中的任何一個失敗（包括測試未通過），則會引發嚴重錯誤。

  • TestBigEndian：定義巨集來判斷位元組順序類型

    檢查系統是大端位元組順序還是小端位元組順序

      TEST_BIG_ENDIAN(VARIABLE)
      VARIABLE - variable to store the result to


  • TestCXXAcceptsFlag：測試 CXX 編譯器是否接受旗標

    檢查 CXX 編譯器是否接受旗標

      Macro CHECK_CXX_ACCEPTS_FLAG(FLAGS VARIABLE) -
         checks if the function exists
      FLAGS - the flags to try
      VARIABLE - variable to store the result


  • TestForANSIForScope：檢查是否支援 ANSI for scope

    檢查編譯器是否在 stl 類別上支援 std::。

      CMAKE_NO_ANSI_FOR_SCOPE - holds result


  • TestForANSIStreamHeaders：測試編譯器是否支援 ANSI 串流標頭 iostream 等

    檢查他們是否有標準的 ansi 串流檔案（沒有 .h）

      CMAKE_NO_ANSI_STREAM_HEADERS - defined by the results


  • TestForSSTREAM:

    # - 測試 std:: 命名空間支援，檢查編譯器是否在 stl 類別上支援 std::

      CMAKE_NO_ANSI_STRING_STREAM - defined by the results


  • TestForSTDNamespace：測試 std:: 命名空間支援

    檢查編譯器是否在 stl 類別上支援 std::

      CMAKE_NO_STD_NAMESPACE - defined by the results


  • UseEcos：此模組定義建置 eCos 應用程式所需的變數和巨集。

    此檔案包含以下巨集：ECOS_ADD_INCLUDE_DIRECTORIES() - 新增 eCos include 目錄 ECOS_ADD_EXECUTABLE(name source1 ... sourceN ) - 建立 eCos 可執行檔 ECOS_ADJUST_DIRECTORY(VAR source1 ... sourceN ) - 調整原始檔的路徑，並將結果放入 VAR 中

    用於選擇工具鏈的巨集：ECOS_USE_ARM_ELF_TOOLS() - 為呼叫它的目錄啟用 ARM ELF 工具鏈 ECOS_USE_I386_ELF_TOOLS() - 為呼叫它的目錄啟用 i386 ELF 工具鏈 ECOS_USE_PPC_EABI_TOOLS() - 為呼叫它的目錄啟用 PowerPC 工具鏈

    它包含以下變數：ECOS_DEFINITIONS ECOSCONFIG_EXECUTABLE ECOS_CONFIG_FILE - 預設為 ecos.ecc，如果您的 eCos 設定檔有不同的名稱，請調整此變數僅供內部使用

      ECOS_ADD_TARGET_LIB
  • UsePkgConfig：用於 CMake 的過時 pkg-config 模組


    定義以下巨集

    PKGCONFIG(package includedir libdir linkflags cflags)

    呼叫 PKGCONFIG 會將所需的資訊填入 4 個給定的引數中，例如 PKGCONFIG(libart-2.0 LIBART_INCLUDE_DIR LIBART_LINK_DIR LIBART_LINK_FLAGS LIBART_CFLAGS) 如果找不到 pkg-config 或指定的軟體套件不存在，則當函式傳回時，變數將會是空的，否則它們將包含各自的資訊

  • UseQt4：用於 QT4 的使用模組

    設定 C 和 C++ 以使用 Qt 4。假設 FindQt.cmake 已載入。如需如何將 Qt 4 載入您的 CMake 專案的資訊，請參閱 FindQt.cmake。

  • UseSWIG：用於 CMake 的 SWIG 模組

    定義以下巨集

       SWIG_ADD_MODULE(name language [ files ])
         - Define swig module with given name and specified language
       SWIG_LINK_LIBRARIES(name [ libraries ])
         - Link libraries to swig module

    所有其他巨集僅供內部使用。若要取得 swig 模組的實際名稱，請使用：${SWIG_MODULE_name_REAL_NAME}。設定原始檔屬性（例如 CPLUSPLUS 和 SWIG_FLAGS）以指定 SWIG 的特殊行為。也可以使用全域 CMAKE_SWIG_FLAGS 來新增特殊旗標至所有 swig 呼叫。另一個特殊變數是 CMAKE_SWIG_OUTDIR，它允許您指定要寫入所有 swig 產生的模組的位置（swig -outdir 選項）。名稱特定的變數 SWIG_MODULE_<name>_EXTRA_DEPS 可用於指定產生的模組的其他相依性。

  • Use_wxWindows: ---------------------------------------------------


    此便利的 include 會找出 wxWindows 是否已安裝，並設定適當的 libs、incdirs、旗標等。作者 Jan Woetzel <jw -at- mip.informatik.uni-kiel.de> (07/2003)

    用法

       just include Use_wxWindows.cmake
       in your projects CMakeLists.txt

    INCLUDE( ${CMAKE_MODULE_PATH}/Use_wxWindows.cmake)

       if you are sure you need GL then

    SET(WXWINDOWS_USE_GL 1)

       *before* you include this file.


    2004 年 2 月 16 日：將 INCLUDE 變更為 FIND_PACKAGE 以從使用者自己的非系統 CMAKE_MODULE_PATH 讀取 (Jan Woetzel JW) 2006 年 7 月：重新撰寫為 FindwxWidgets.cmake，保留以實現向後相容性 JW

  • UsewxWidgets：用於使用 wxWidgets 程式庫的便利 include

    找出 wxWidgets 是否已安裝，並設定適當的 libs、incdirs、旗標等。會呼叫 INCLUDE_DIRECTORIES、LINK_DIRECTORIES 和 ADD_DEFINITIONS。

    用法

      SET( wxWidgets_USE_LIBS  gl xml xrc ) # optionally: more than wx std libs
      FIND_PACKAGE(wxWidgets REQUIRED)
      INCLUDE( ${xWidgets_USE_FILE} )
      ... add your targets here, e.g. ADD_EXECUTABLE/ ADD_LIBRARY ...
      TARGET_LINK_LIBRARIERS( <yourWxDependantTarget>  ${wxWidgets_LIBRARIES})


    已過時

      LINK_LIBRARIES is not called in favor of adding dependencies per target.


    作者

      Jan Woetzel <jw -at- mip.informatik.uni-kiel.de>

政策

  • CMP0000：必須指定最小要求的 CMake 版本。

    CMake 要求專案指定它們撰寫所用的 CMake 版本。制定此原則是為了讓嘗試建置專案的使用者知道何時需要更新他們的 CMake。指定版本也有助於專案使用比指定版本更新的 CMake 版本進行建置。在您的主要 CMakeLists.txt 檔案的頂端使用 cmake_minimum_required 命令

      cmake_minimum_required(VERSION <major>.<minor>)

    其中 "<major>.<minor>" 是您想要支援的 CMake 版本（例如 "2.6"）。該命令將確保至少執行給定的 CMake 版本，並協助較新的版本與專案相容。如需詳細資料，請參閱 cmake_minimum_required 的文件。

    請注意，命令呼叫必須出現在 CMakeLists.txt 檔案本身中；在包含的檔案中呼叫是不夠的。不過，可以呼叫 cmake_policy 命令來將原則 CMP0000 明確設定為 OLD 或 NEW 行為。OLD 行為是靜默忽略遺失的呼叫。NEW 行為是發出錯誤而不是警告。包含的檔案可以明確設定 CMP0000，以影響如何對主要 CMakeLists.txt 檔案強制執行此原則。

    此原則是在 CMake 2.6.0 版中引入的。

  • CMP0001：不應再使用 CMAKE_BACKWARDS_COMPATIBILITY。

    OLD 行為是檢查 CMAKE_BACKWARDS_COMPATIBILITY 並將其呈現給使用者。NEW 行為是完全忽略 CMAKE_BACKWARDS_COMPATIBILITY。

    在 CMake 2.4 和更早版本中，變數 CMAKE_BACKWARDS_COMPATIBILITY 用於要求與較早版本的 CMake 相容。在 CMake 2.6 及以上版本中，所有相容性問題都由原則和 cmake_policy 命令處理。不過，CMake 仍必須針對為 CMake 2.4 和更早版本撰寫的專案檢查 CMAKE_BACKWARDS_COMPATIBILITY。

    此原則是在 CMake 2.6.0 版中引入的。當原則未設定時，CMake 2.6 版會發出警告並使用 OLD 行為。使用 cmake_policy 命令將其明確設定為 OLD 或 NEW。

  • CMP0002：邏輯目標名稱必須是全域唯一的。

    使用 add_executable、add_library 或 add_custom_target 建立的目標名稱是邏輯建置目標名稱。邏輯目標名稱必須是全域唯一的，因為

      - Unique names may be referenced unambiguously both in CMake
        code and on make tool command lines.
      - Logical names are used by Xcode and VS IDE generators
        to produce meaningful project names for the targets.

    可執行檔和程式庫目標的邏輯名稱不一定要對應到建置的實體檔名。請考慮使用 OUTPUT_NAME 目標屬性來建立兩個具有相同實體名稱的目標，同時保持邏輯名稱不同。自訂目標必須簡單地具有全域唯一的名稱（除非您將全域屬性 ALLOW_DUPLICATE_CUSTOM_TARGETS 與 Makefiles 產生器一起使用）。

    此原則是在 CMake 2.6.0 版中引入的。當原則未設定時，CMake 2.6 版會發出警告並使用 OLD 行為。使用 cmake_policy 命令將其明確設定為 OLD 或 NEW。

  • CMP0003：透過完整路徑連結的程式庫不再產生連結器搜尋路徑。

    此原則會影響在連結時間如何找到完整路徑「未」知的程式庫，但其建立的原因是 CMake 處理完整路徑已知的程式庫的方式發生變更。請考慮程式碼

      target_link_libraries(myexe /path/to/libA.so)

    CMake 2.4 和更早版本實作連結至完整路徑已知的程式庫的方式是，將它們在連結行上分割為由連結器搜尋路徑和程式庫名稱組成的個別元件。範例程式碼可能會產生類似

      ... -L/path/to -lA ...

    以連結至程式庫 A。會執行分析來排序多個連結目錄，以便連結器在所需的位置找到程式庫 A，但在某些情況下，這不起作用。CMake 2.6 及以上版本使用更可靠的方法，在大多數情況下將程式庫的完整路徑直接傳遞給連結器。範例程式碼現在產生類似

      ... /path/to/libA.so ....

    不幸的是，此變更可能會中斷類似以下的程式碼

      target_link_libraries(myexe /path/to/libA.so B)

    其中 "B" 表示尋找 "/path/to/libB.so"。此程式碼是錯誤的，因為使用者要求連結器尋找程式庫 B，但未提供連結器搜尋路徑（可以使用 link_directories 命令新增）。不過，使用舊的連結實作，程式碼會意外運作，因為為程式庫 A 新增的連結器搜尋路徑允許找到程式庫 B。

    為了支援依賴於連結到具有已知完整路徑的程式庫所新增的連結器搜尋路徑的專案，此原則的 OLD 行為會新增連結器搜尋路徑，即使它們對於它們自己的程式庫來說不是必要的。當此原則設定為 OLD 時，CMake 會產生如下的連結行

      ... -L/path/to /path/to/libA.so -lB ...

    這會允許像之前一樣找到程式庫 B。當此原則設定為 NEW 時，CMake 會產生如下的連結行

      ... /path/to/libA.so -lB ...

    這更準確地符合專案指定的內容。

    在透過 add_executable 或 add_library 命令建立目標時生效的原則設定，用於產生連結行。對於上述範例，程式碼

      cmake_policy(SET CMP0003 OLD) # or cmake_policy(VERSION 2.4)
      add_executable(myexe myexe.c)
      target_link_libraries(myexe /path/to/libA.so B)

    將會運作，並抑制此原則的警告。它也可以更新為使用更正的連結方法運作

      cmake_policy(SET CMP0003 NEW) # or cmake_policy(VERSION 2.6)
      link_directories(/path/to) # needed to find library B
      add_executable(myexe myexe.c)
      target_link_libraries(myexe /path/to/libA.so B)

    更好的是，可以使用完整路徑指定程式庫 B

      add_executable(myexe myexe.c)
      target_link_libraries(myexe /path/to/libA.so /path/to/libB.so)

    當連結行上的所有項目都具有已知路徑時，CMake 不會檢查此原則，因此它沒有效果。

    請注意，此原則的警告最多會針對一個目標發出。這樣可以避免在設定一次原則可能會修復所有目標時，以訊息淹沒使用者。

    此原則是在 CMake 2.6.0 版中引入的。當原則未設定時，CMake 2.6 版會發出警告並使用 OLD 行為。使用 cmake_policy 命令將其明確設定為 OLD 或 NEW。

  • CMP0004：連結的程式庫可能沒有開頭或結尾的空白字元。

    CMake 2.4 和更早版本會靜默地移除透過類似程式碼連結的程式庫中的開頭和結尾空白字元

      target_link_libraries(myexe " A ")

    這可能會導致使用者專案中出現細微的錯誤。

    此原則的 OLD 行為是靜默地移除開頭和結尾的空白字元。此原則的 NEW 行為是將此類空白字元的存在診斷為錯誤。在透過 add_executable 或 add_library 命令建立目標時生效的原則設定，用於檢查程式庫名稱。

    此原則是在 CMake 2.6.0 版中引入的。當原則未設定時，CMake 2.6 版會發出警告並使用 OLD 行為。使用 cmake_policy 命令將其明確設定為 OLD 或 NEW。

  • CMP0005：預處理器定義值現在會自動逸出。

    此原則決定 CMake 是否應產生透過 add_definitions 加入的跳脫前處理器定義值。CMake 2.4 及更早的版本假設 add_definitions 呼叫中的巨集只會提供簡單的值。它不會嘗試在產生的建置規則中跳脫非簡單值，例如字串字面值。CMake 2.6 及更新版本支援大多數值的跳脫，但無法假設使用者為了避開早期版本的限制，已經加入了跳脫字元。

    此原則的舊行為是將 add_definitions 提供的值直接放置在產生的建置規則中，而不嘗試跳脫任何內容。此原則的新行為是自動為所有原生建置工具產生正確的跳脫字元。有關跳脫實作的限制，請參閱 COMPILE_DEFINITIONS 目標屬性的文件。

    此原則是在 CMake 2.6.0 版中引入的。當原則未設定時，CMake 2.6 版會發出警告並使用 OLD 行為。使用 cmake_policy 命令將其明確設定為 OLD 或 NEW。

  • CMP0006：安裝 MACOSX_BUNDLE 目標需要 BUNDLE DESTINATION。

    此原則決定當要求安裝設定了 MACOSX_BUNDLE 屬性的目標時，是否必須為 install(TARGETS) 命令提供 BUNDLE DESTINATION。CMake 2.4 及更早版本在安裝目標時不會區分應用程式套件和一般可執行檔。CMake 2.6 為 install(TARGETS) 命令提供了一個 BUNDLE 選項，用於指定 Mac 上應用程式套件的特定規則。專案在安裝設定了 MACOSX_BUNDLE 屬性的目標時，應使用此選項。

    此原則的舊行為是在未提供 BUNDLE DESTINATION 時回退到 RUNTIME DESTINATION。此原則的新行為是如果安裝套件目標時未提供 BUNDLE DESTINATION，則會產生錯誤。

    此原則是在 CMake 2.6.0 版中引入的。當原則未設定時，CMake 2.6 版會發出警告並使用 OLD 行為。使用 cmake_policy 命令將其明確設定為 OLD 或 NEW。

  • CMP0007：list 命令不再忽略空元素。

    此原則決定 list 命令是否會忽略清單中的空元素。CMake 2.4 及更早版本的 list 命令會忽略清單中的所有空元素。例如，a;b;;c 的長度將為 3 而非 4。此原則的舊行為是忽略清單中的空元素。此原則的新行為是正確計算清單中的空元素。

    此原則是在 CMake 2.6.0 版中引入的。當原則未設定時，CMake 2.6 版會發出警告並使用 OLD 行為。使用 cmake_policy 命令將其明確設定為 OLD 或 NEW。

  • CMP0008：以完整路徑連結的程式庫必須具有有效的程式庫檔案名稱。

    在 CMake 2.4 及更早版本中，可以編寫如下程式碼：

      target_link_libraries(myexe /full/path/to/somelib)

    其中 "somelib" 應該是有效的程式庫檔案名稱，例如 "libsomelib.a" 或 "somelib.lib"。對於 Makefile 產生器，這會在建置時產生錯誤，因為找不到完整路徑的相依性。對於 VS IDE 和 Xcode 產生器，這過去可以意外地運作，因為 CMake 總是會分割出程式庫目錄，並要求連結器按名稱搜尋程式庫（-lsomelib 或 somelib.lib）。儘管 Makefile 出現失敗，但有些專案有類似的程式碼，並且僅使用 VS 和/或 Xcode 進行建置。此版本的 CMake 偏好將完整路徑直接傳遞給原生建置工具，這在這種情況下會失敗，因為它並未命名有效的程式庫檔案。

    此原則決定如何處理看起來未命名有效程式庫檔案的完整路徑。此原則的舊行為是將程式庫名稱從路徑中分割出來，並要求連結器搜尋它。此原則的新行為是信任給定的路徑，並將其直接傳遞給原生建置工具，而不做任何變更。

    此原則是在 CMake 2.6.1 版中引入的。CMake 2.6 版在未設定此原則時會發出警告，並使用舊行為。請使用 cmake_policy 命令將其明確設定為 OLD 或 NEW。

  • CMP0009：FILE GLOB_RECURSE 呼叫預設不應追蹤符號連結。

    在 CMake 2.6.1 及更早版本中，FILE GLOB_RECURSE 呼叫會追蹤符號連結，有時會因為指向包含數十萬個檔案的頂層目錄的符號連結而產生意外的大型結果集。

    此原則決定是否追蹤在 FILE GLOB_RECURSE 呼叫期間遇到的符號連結。此原則的舊行為是追蹤符號連結。此原則的新行為是預設不追蹤符號連結，除非將 FOLLOW_SYMLINKS 作為 FILE 命令的附加引數提供。

    此原則是在 CMake 2.6.2 版中引入的。CMake 2.6 版在未設定此原則時會發出警告，並使用舊行為。請使用 cmake_policy 命令將其明確設定為 OLD 或 NEW。

  • CMP0010：錯誤的變數參考語法是錯誤。

    在 CMake 2.6.2 及更早版本中，不正確的變數參考語法（例如遺失右大括號（"${FOO"））會被報告，但不會停止 CMake 程式碼的處理。此原則決定錯誤的變數參考是否為錯誤。此原則的舊行為是警告錯誤、保持字串不變並繼續。此原則的新行為是回報錯誤。

    此原則是在 CMake 2.6.3 版中引入的。CMake 2.6 版在未設定此原則時會發出警告，並使用舊行為。請使用 cmake_policy 命令將其明確設定為 OLD 或 NEW。

  • CMP0011：包含的指令碼會自動執行 cmake_policy PUSH 和 POP。

    在 CMake 2.6.2 及更早版本中，由 include() 和 find_package() 命令載入的指令碼中的 CMake 原則設定會影響包含者。需要明確呼叫 cmake_policy(PUSH) 和 cmake_policy(POP) 來隔離原則變更並保護包含者。雖然某些指令碼旨在影響其包含者的原則，但大多數情況並非如此。在 CMake 2.6.3 及更新版本中，include() 和 find_package() 預設會在包含的指令碼周圍 PUSH 和 POP 原則堆疊上的項目，但提供 NO_POLICY_SCOPE 選項來停用它。此原則決定是否為了相容性而暗示 NO_POLICY_SCOPE。此原則的舊行為是為 include() 和 find_package() 命令暗示 NO_POLICY_SCOPE。此原則的新行為是允許命令執行其預設的 cmake_policy PUSH 和 POP。

    此原則是在 CMake 2.6.3 版中引入的。CMake 2.6 版在未設定此原則時會發出警告，並使用舊行為。請使用 cmake_policy 命令將其明確設定為 OLD 或 NEW。

變數

變更行為的變數

  • BUILD_SHARED_LIBS：全域旗標，若開啟，則使 add_library 建立共享程式庫。

    如果存在且為 true，則會導致所有程式庫都以共享方式建置，除非程式庫已明確新增為靜態程式庫。此變數通常會以 OPTION 的形式新增到專案中，以便專案的每個使用者都可以決定是否要使用共享程式庫或靜態程式庫來建置專案。

  • CMAKE_BACKWARDS_COMPATIBILITY：建置專案所需的 CMake 版本

    從回溯相容性的角度來看，這指定應支援哪個版本的 CMake。預設情況下，此值為您正在執行的 CMake 版本號碼。您可以將其設定為較舊版本的 CMake，以支援為使用較舊版本的 CMake 而編寫的專案中已棄用的 CMake 命令。使用者可以設定此值，或在 CMakeLists 檔案的開頭設定此值。

  • CMAKE_BUILD_TYPE：指定基於 make 的產生器的建置類型。

    這指定在此樹狀結構中將要建置的建置類型。可能的值為空、Debug、Release、RelWithDebInfo 和 MinSizeRel。此變數僅支援基於 make 的產生器。如果支援此變數，則 CMake 還將為名稱為 CMAKE_C_FLAGS_[Debug|Release|RelWithDebInfo|MinSizeRel] 的變數提供初始值。例如，如果 CMAKE_BUILD_TYPE 為 Debug，則 CMAKE_C_FLAGS_DEBUG 將會新增到 CMAKE_C_FLAGS。

  • CMAKE_COLOR_MAKEFILE：使用 Makefile 產生器時啟用彩色輸出。

    啟用後，產生的 Makefile 將會產生彩色輸出。預設值為 ON。

  • CMAKE_CONFIGURATION_TYPES：指定可用的建置類型。

    這指定將可用的建置類型，例如 Debug、Release、RelWithDebInfo 等。在大多數平台上，這都有合理的預設值。但是可以擴充以提供其他建置類型。另請參閱 CMAKE_BUILD_TYPE。

  • CMAKE_FIND_LIBRARY_PREFIXES：在尋找程式庫時要新增的前置詞。

    這指定當 find_library 命令尋找程式庫時，要新增到程式庫名稱的前置詞。在 UNIX 系統上，這通常是 lib，這表示在嘗試尋找 foo 程式庫時，它會尋找 libfoo。

  • CMAKE_FIND_LIBRARY_SUFFIXES：在尋找程式庫時要附加的後置詞。

    這指定當 find_library 命令尋找程式庫時，要新增到程式庫名稱的後置詞。在 Windows 系統上，這通常是 .lib 和 .dll，這表示在嘗試尋找 foo 程式庫時，它會尋找 foo.dll 等。

  • CMAKE_INCLUDE_PATH：用於 FIND_FILE() 和 FIND_PATH() 搜尋的路徑。

    指定 FIND_FILE() 和 FIND_PATH() 都會使用的路徑。這兩個命令都會檢查每個包含的目錄中是否存在目前正在搜尋的檔案。預設情況下為空，它旨在由專案設定。另請參閱 CMAKE_SYSTEM_INCLUDE_PATH、CMAKE_PREFIX_PATH。

  • CMAKE_INSTALL_PREFIX：install 使用的安裝目錄。

    如果呼叫 "make install" 或建置 INSTALL，則此目錄會附加到所有安裝目錄。此變數在 UNIX 上預設為 /usr/local，在 Windows 上預設為 c:/Program Files。

  • CMAKE_LIBRARY_PATH：用於 FIND_LIBRARY() 搜尋的路徑。

    指定 FIND_LIBRARY() 將會使用的路徑。FIND_LIBRARY() 會檢查每個包含的目錄中是否存在目前正在搜尋的程式庫。預設情況下為空，它旨在由專案設定。另請參閱 CMAKE_SYSTEM_LIBRARY_PATH、CMAKE_PREFIX_PATH。

  • CMAKE_MFC_FLAG：告知 cmake 為可執行檔或 dll 使用 MFC。

    這可以在 CMakeLists.txt 檔案中設定，並在應用程式中啟用 MFC。靜態 MFC 函式庫應設定為 1，而共用 MFC 函式庫應設定為 2。這用於 Visual Studio 6 和 7 的專案檔案中。CMakeSetup 對話框使用 MFC，而 CMakeLists.txt 看起來像這樣

    ADD_DEFINITIONS(-D_AFXDLL)

    set(CMAKE_MFC_FLAG 2)

    add_executable(CMakeSetup WIN32 ${SRCS})

  • CMAKE_MODULE_PATH：要載入的 cmake 模組的搜尋路徑。

    指定一個路徑來覆寫 CMake 模組的預設搜尋路徑。例如，include 命令會先在這個路徑中尋找要包含的模組。

  • CMAKE_NOT_USING_CONFIG_FLAGS：如果為 true，則跳過 _BUILD_TYPE 旗標。

    這是 CMake 中產生器使用的內部旗標，用來告知 CMake 跳過 _BUILD_TYPE 旗標。

  • CMAKE_PREFIX_PATH：用於 FIND_XXX() 搜尋的路徑，並加上適當的後綴。

    指定 FIND_XXX() 命令將使用的路徑。它包含「基本」目錄，FIND_XXX() 命令會將適當的子目錄附加到基本目錄。因此，FIND_PROGRAM() 會將 /bin 加到路徑中的每個目錄，FIND_LIBRARY() 會將 /lib 附加到每個目錄，而 FIND_PATH() 和 FIND_FILE() 會附加 /include。預設情況下，它是空的，旨在由專案設定。另請參閱 CMAKE_SYSTEM_PREFIX_PATH、CMAKE_INCLUDE_PATH、CMAKE_LIBRARY_PATH、CMAKE_PROGRAM_PATH。

  • CMAKE_PROGRAM_PATH：用於 FIND_PROGRAM() 搜尋的路徑。

    指定 FIND_PROGRAM() 將使用的路徑。FIND_PROGRAM() 將檢查包含的每個目錄中是否存在目前正在搜尋的程式。預設情況下，它是空的，旨在由專案設定。另請參閱 CMAKE_SYSTEM_PROGRAM_PATH、CMAKE_PREFIX_PATH。

  • CMAKE_SYSTEM_INCLUDE_PATH：用於 FIND_FILE() 和 FIND_PATH() 搜尋的路徑。

    指定 FIND_FILE() 和 FIND_PATH() 都會使用的路徑。這兩個命令都會檢查包含的每個目錄中是否存在目前正在搜尋的檔案。預設情況下，它包含目前系統的標準目錄。不應由專案修改，請使用 CMAKE_INCLUDE_PATH 來執行此操作。另請參閱 CMAKE_SYSTEM_PREFIX_PATH。

  • CMAKE_SYSTEM_LIBRARY_PATH：用於 FIND_LIBRARY() 搜尋的路徑。

    指定 FIND_LIBRARY() 將使用的路徑。FIND_LIBRARY() 將檢查包含的每個目錄中是否存在目前正在搜尋的函式庫。預設情況下，它包含目前系統的標準目錄。不應由專案修改，請使用 CMAKE_SYSTEM_LIBRARY_PATH 來執行此操作。另請參閱 CMAKE_SYSTEM_PREFIX_PATH。

  • CMAKE_SYSTEM_PREFIX_PATH：用於 FIND_XXX() 搜尋的路徑，並加上適當的後綴。

    指定 FIND_XXX() 命令將使用的路徑。它包含「基本」目錄，FIND_XXX() 命令會將適當的子目錄附加到基本目錄。因此，FIND_PROGRAM() 會將 /bin 加到路徑中的每個目錄，FIND_LIBRARY() 會將 /lib 附加到每個目錄，而 FIND_PATH() 和 FIND_FILE() 會附加 /include。預設情況下，這包含目前系統的標準目錄。不應由專案修改，請使用 CMAKE_PREFIX_PATH 來執行此操作。另請參閱 CMAKE_SYSTEM_INCLUDE_PATH、CMAKE_SYSTEM_LIBRARY_PATH、CMAKE_SYSTEM_PROGRAM_PATH。

  • CMAKE_SYSTEM_PROGRAM_PATH：用於 FIND_PROGRAM() 搜尋的路徑。

    指定 FIND_PROGRAM() 將使用的路徑。FIND_PROGRAM() 將檢查包含的每個目錄中是否存在目前正在搜尋的程式。預設情況下，它包含目前系統的標準目錄。不應由專案修改，請使用 CMAKE_PROGRAM_PATH 來執行此操作。另請參閱 CMAKE_SYSTEM_PREFIX_PATH。

  • CMAKE_USER_MAKE_RULES_OVERRIDE：指定一個可以變更建置規則變數的檔案。

    如果設定此變數，它應該指向一個 CMakeLists.txt 檔案，該檔案將在設定所有系統設定之後但在使用它們之前，由 CMake 讀取。這可讓您覆寫一些特殊專案需要變更的任何變數。

描述系統的變數

  • APPLE：如果在 Mac OSX 上執行則為 True。

    在 Mac OSX 上設定為 true。

  • BORLAND：如果正在使用 borland 編譯器則為 True。

    如果正在使用 Borland 編譯器，則設定為 true。

  • CMAKE_CL_64：使用 Microsoft 的 64 位元編譯器

    使用 Microsoft 的 64 位元 cl 編譯器時設定為 true。

  • CMAKE_COMPILER_2005：使用 Microsoft 的 Visual Studio 2005 編譯器

    使用 Microsoft 的 Visual Studio 2005 編譯器時設定為 true。

  • CMAKE_HOST_APPLE：對於 Apple OSX 作業系統為 True。

    當主機系統是 Apple OSX 時設定為 true。

  • CMAKE_HOST_SYSTEM：cmake 正在執行的系統名稱。

    與 CMAKE_SYSTEM 相同，但用於主機系統而不是交叉編譯時的目標系統。

  • CMAKE_HOST_SYSTEM_NAME：CMake 正在執行的作業系統名稱。

    與 CMAKE_SYSTEM_NAME 相同，但用於主機系統而不是交叉編譯時的目標系統。

  • CMAKE_HOST_SYSTEM_PROCESSOR：CMake 正在執行的 CPU 名稱。

    與 CMAKE_SYSTEM_PROCESSOR 相同，但用於主機系統而不是交叉編譯時的目標系統。

  • CMAKE_HOST_SYSTEM_VERSION：CMake 正在執行的作業系統版本。

    與 CMAKE_SYSTEM_VERSION 相同，但用於主機系統而不是交叉編譯時的目標系統。

  • CMAKE_HOST_UNIX：對於 UNIX 和類 UNIX 作業系統為 True。

    當主機系統為 UNIX 或類 UNIX 時（即 APPLE 和 CYGWIN）設定為 true。

  • CMAKE_HOST_WIN32：在 Windows 系統（包括 win64）上為 True。

    當主機系統為 Windows 且在 cygwin 上時設定為 true。

  • CMAKE_OBJECT_PATH_MAX：原生建置工具允許的最大物件檔完整路徑長度。

    CMake 會為每個原始檔計算一個物件檔名稱，該名稱對於原始檔是唯一的，並且對於原始檔的完整路徑是確定的。這允許目標中的多個原始檔在不同目錄中時共用相同的名稱，而不會在新增或移除其中一個原始檔時重建。但是，在少數情況下，它可能會產生長的完整路徑，因此當物件檔的完整路徑超過限制時，CMake 會使用雜湊機制縮短路徑。CMake 針對每個平台都有一個內建限制，足以用於常見的工具，但某些原生工具可能具有較低的限制。可以設定此變數來明確指定限制。該值必須是不小於 128 的整數。

  • CMAKE_SYSTEM：cmake 正在編譯的系統名稱。

    此變數是 CMAKE_SYSTEM_NAME 和 CMAKE_SYSTEM_VERSION 的組合，如下所示：${CMAKE_SYSTEM_NAME}-${CMAKE_SYSTEM_VERSION}。如果未設定 CMAKE_SYSTEM_VERSION，則 CMAKE_SYSTEM 與 CMAKE_SYSTEM_NAME 相同。

  • CMAKE_SYSTEM_NAME：CMake 正在為其建置的作業系統名稱。

    這是 CMake 正在鎖定的作業系統名稱。在具有 uname 命令的系統上，此變數設定為 uname -s 的輸出。Linux、Windows 和 Mac OSX 的 Darwin 是在三大作業系統上找到的值。

  • CMAKE_SYSTEM_PROCESSOR：CMake 正在為其建置的 CPU 名稱。

    在支援 uname 的系統上，此變數設定為 uname -p 的輸出，在 Windows 上，它設定為環境變數 PROCESSOR_ARCHITECTURE 的值

  • CMAKE_SYSTEM_VERSION：CMake 正在為其建置的作業系統版本。

    系統的數字版本字串，在支援 uname 的系統上，此變數設定為 uname -r 的輸出。在其他系統上，這會設定為主要版本號碼-次要版本號碼。

  • CYGWIN：對於 cygwin 為 True。

    使用 CYGWIN 時設定為 true。

  • MSVC：使用 Microsoft Visual C 時為 True

    當編譯器是某個版本的 Microsoft Visual C 時設定為 true。

  • MSVC80：使用 Microsoft Visual C 8.0 時為 True

    當編譯器是 Microsoft Visual C 的 8.0 版本時設定為 true。

  • MSVC_IDE：使用 Microsoft Visual C IDE 時為 True

    當目標平台是 Microsoft Visual C IDE 而不是命令列編譯器時設定為 true。

  • MSVC_VERSION：正在使用的 Microsoft Visual C/C++ 版本（如果有的話）。

    正在使用的 Microsoft Visual C/C++ 版本（如果有的話）。例如，1300 是 MSVC 6.0。

  • UNIX：對於 UNIX 和類 UNIX 作業系統為 True。

    當目標系統為 UNIX 或類 UNIX 時（即 APPLE 和 CYGWIN）設定為 true。

  • WIN32：在 Windows 系統（包括 win64）上為 True。

    當目標系統為 Windows 且在 cygwin 上時設定為 true。

語言的變數

  • CMAKE_<LANG>_ARCHIVE_APPEND: 用於附加到靜態函式庫的規則變數。

    這是一個規則變數，告訴 CMake 如何附加到靜態函式庫。它在某些平台上會取代 CMAKE_<LANG>_CREATE_STATIC_LIBRARY 使用，以支援大量的物件計數。另請參閱 CMAKE_<LANG>_ARCHIVE_CREATE 和 CMAKE_<LANG>_ARCHIVE_FINISH。

  • CMAKE_<LANG>_ARCHIVE_CREATE: 用於建立新的靜態函式庫的規則變數。

    這是一個規則變數，告訴 CMake 如何建立靜態函式庫。它在某些平台上會取代 CMAKE_<LANG>_CREATE_STATIC_LIBRARY 使用，以支援大量的物件計數。另請參閱 CMAKE_<LANG>_ARCHIVE_APPEND 和 CMAKE_<LANG>_ARCHIVE_FINISH。

  • CMAKE_<LANG>_ARCHIVE_FINISH: 用於完成現有靜態函式庫的規則變數。

    這是一個規則變數，告訴 CMake 如何完成靜態函式庫。它在某些平台上會取代 CMAKE_<LANG>_CREATE_STATIC_LIBRARY 使用，以支援大量的物件計數。另請參閱 CMAKE_<LANG>_ARCHIVE_CREATE 和 CMAKE_<LANG>_ARCHIVE_APPEND。

  • CMAKE_<LANG>_COMPILER: LANG 編譯器的完整路徑。

    這是將用作 <LANG> 編譯器的命令。設定後，您無法變更此變數。

  • CMAKE_<LANG>_COMPILER_ABI: 一個內部變數，可能會變更。

    這用於判斷編譯器 ABI，且可能會變更。

  • CMAKE_<LANG>_COMPILER_ID: 一個內部變數，可能會變更。

    這用於判斷編譯器，且可能會變更。

  • CMAKE_<LANG>_COMPILE_OBJECT: 用於編譯單一物件檔的規則變數。

    這是一個規則變數，告訴 CMake 如何針對 <LANG> 語言編譯單一物件檔。

  • CMAKE_<LANG>_CREATE_SHARED_LIBRARY: 用於建立共享函式庫的規則變數。

    這是一個規則變數，告訴 CMake 如何針對 <LANG> 語言建立共享函式庫。

  • CMAKE_<LANG>_CREATE_SHARED_MODULE: 用於建立共享模組的規則變數。

    這是一個規則變數，告訴 CMake 如何針對 <LANG> 語言建立共享函式庫。

  • CMAKE_<LANG>_CREATE_STATIC_LIBRARY: 用於建立靜態函式庫的規則變數。

    這是一個規則變數，告訴 CMake 如何針對 <LANG> 語言建立靜態函式庫。

  • CMAKE_<LANG>_FLAGS_DEBUG: 用於 Debug 建置類型或組態的旗標。

    當 CMAKE_BUILD_TYPE 為 Debug 時使用的 <LANG> 旗標。

  • CMAKE_<LANG>_FLAGS_MINSIZEREL: 用於 MinSizeRel 建置類型或組態的旗標。

    當 CMAKE_BUILD_TYPE 為 MinSizeRel 時使用的 <LANG> 旗標。MinSizeRel 是最小大小發行的縮寫。

  • CMAKE_<LANG>_FLAGS_RELEASE: 用於 Release 建置類型或組態的旗標。

    當 CMAKE_BUILD_TYPE 為 Release 時使用的 <LANG> 旗標。

  • CMAKE_<LANG>_FLAGS_RELWITHDEBINFO: 用於 RelWithDebInfo 類型或組態的旗標。

    當 CMAKE_BUILD_TYPE 為 RelWithDebInfo 時使用的 <LANG> 旗標。RelWithDebInfo 是 Release With Debug Information (發行版本與偵錯資訊) 的縮寫。

  • CMAKE_<LANG>_IGNORE_EXTENSIONS: 建置時應忽略的檔案副檔名。

    這是檔案副檔名清單，這些副檔名可能是給定語言專案的一部分，但不會被編譯。

  • CMAKE_<LANG>_LINKER_PREFERENCE: 判斷是否應使用語言進行連結。

    如果這是「偏好」，則如果有混合語言的共享函式庫或可執行檔，則會使用此語言的連結器命令。

  • CMAKE_<LANG>_LINK_EXECUTABLE : 用於連結可執行檔的規則變數。

    用於連結給定語言可執行檔的規則變數。

  • CMAKE_<LANG>_OUTPUT_EXTENSION: 單一檔案編譯輸出的副檔名。

    這是給定 <LANG> 的物件檔副檔名。例如，Windows 上 C 的 .obj。

  • CMAKE_<LANG>_PLATFORM_ID: 一個內部變數，可能會變更。

    這用於判斷平台，且可能會變更。

  • CMAKE_<LANG>_SIZEOF_DATA_PTR: 一個內部變數，可能會變更。

    這用於判斷架構，且可能會變更。

  • CMAKE_<LANG>_SOURCE_FILE_EXTENSIONS: 給定語言的原始程式檔副檔名。

    這是給定語言原始程式檔的副檔名清單。

  • CMAKE_COMPILER_IS_GNU<LANG>: 如果編譯器是 GNU，則為 True。

    如果選取的 <LANG> 編譯器是 GNU 編譯器，則此為 TRUE，否則為 FALSE。

  • CMAKE_INTERNAL_PLATFORM_ABI: 一個內部變數，可能會變更。

    這用於判斷編譯器 ABI，且可能會變更。

  • CMAKE_USER_MAKE_RULES_OVERRIDE_<LANG>: 指定一個可以變更建置規則變數的檔案。

    如果設定此變數，則應指向 CMakeLists.txt 檔案，該檔案會在所有系統設定設定完成後，但在使用它們之前由 CMake 讀取。這可讓您覆寫某些語言需要變更的任何變數。

控制建構的變數

  • CMAKE_<CONFIG>_POSTFIX: 組態 <CONFIG> 下函式庫的預設檔案名稱後綴。

    建立非可執行目標時，如果設定此變數，其 <CONFIG>_POSTFIX 目標屬性會以該變數的值初始化。

  • CMAKE_ARCHIVE_OUTPUT_DIRECTORY: 建置時放置所有 ARCHIVE 目標的位置。

    此變數用於初始化所有目標的 ARCHIVE_OUTPUT_DIRECTORY 屬性。請參閱該目標屬性以取得其他資訊。

  • CMAKE_BUILD_WITH_INSTALL_RPATH: 將安裝路徑用於 RPATH。

    通常，CMake 在使用 RPATH 的系統上建置可執行檔等時，會將建置樹狀結構用於 RPATH。當安裝軟體時，CMake 會重新連結可執行檔等，以具有安裝 RPATH。如果此變數設定為 true，則軟體始終使用安裝路徑建置 RPATH，且在安裝時不需要重新連結。

  • CMAKE_DEBUG_POSTFIX: 請參閱變數 CMAKE_<CONFIG>_POSTFIX。

    此變數是針對 DEBUG 組態更通用的 CMAKE_<CONFIG>_POSTFIX 變數的特殊案例。

  • CMAKE_EXE_LINKER_FLAGS: 用於建立可執行檔的連結器旗標。

    連結器在建立可執行檔時使用的旗標。

  • CMAKE_EXE_LINKER_FLAGS_[CMAKE_BUILD_TYPE]: 連結可執行檔時使用的旗標。

    與 CMAKE_C_FLAGS_* 相同，但由連結器在建立可執行檔時使用。

  • CMAKE_Fortran_MODULE_DIRECTORY: Fortran 模組輸出目錄。

    此變數用於初始化所有目標的 Fortran_MODULE_DIRECTORY 屬性。請參閱該目標屬性以取得其他資訊。

  • CMAKE_INSTALL_NAME_DIR: Mac OSX 已安裝目標的目錄名稱。

    CMAKE_INSTALL_NAME_DIR 用於初始化所有目標的 INSTALL_NAME_DIR 屬性。請參閱該目標屬性以取得其他資訊。

  • CMAKE_INSTALL_RPATH: 用於已安裝目標的 rpath。

    以分號分隔的清單，指定用於已安裝目標的 rpath (適用於支援 rpath 的平台)。這用於初始化所有目標的目標屬性 INSTALL_RPATH。

  • CMAKE_INSTALL_RPATH_USE_LINK_PATH: 將路徑新增至連結器搜尋和已安裝的 rpath。

    CMAKE_INSTALL_RPATH_USE_LINK_PATH 是一個布林值，如果設定為 true，則會將連結器搜尋路徑中且在專案外部的目錄附加至 INSTALL_RPATH。這用於初始化所有目標的目標屬性 INSTALL_RPATH_USE_LINK_PATH。

  • CMAKE_LIBRARY_OUTPUT_DIRECTORY: 建置時放置所有 LIBRARY 目標的位置。

    此變數用於初始化所有目標的 LIBRARY_OUTPUT_DIRECTORY 屬性。請參閱該目標屬性以取得其他資訊。

  • CMAKE_LIBRARY_PATH_FLAG: 用於將函式庫搜尋路徑新增至編譯器的旗標。

    用於指定函式庫目錄給編譯器的旗標。在大多數編譯器上，這是 "-L"。

  • CMAKE_LINK_DEF_FILE_FLAG : 用於指定 dll 建立的 .def 檔案的連結器旗標。

    在 Windows 上建立 dll 時用於新增 .def 檔案的旗標，這僅在 Windows 上定義。

  • CMAKE_LINK_LIBRARY_FILE_FLAG: 用於連結由其檔案路徑指定的函式庫的旗標。

    在將函式庫檔案路徑提供給連結器之前使用的旗標。這僅在極少數的平台上需要。

  • CMAKE_LINK_LIBRARY_FLAG: 用於將函式庫連結至可執行檔的旗標。

    用於指定要連結至可執行檔的函式庫的旗標。在大多數編譯器上，這是 "-l"。

  • CMAKE_RUNTIME_OUTPUT_DIRECTORY: 建置時放置所有 RUNTIME 目標的位置。

    此變數用於初始化所有目標的 RUNTIME_OUTPUT_DIRECTORY 屬性。請參閱該目標屬性以取得其他資訊。

  • CMAKE_SKIP_BUILD_RPATH: 請勿在建置樹狀結構中包含 RPATH。

    通常，CMake 在使用 RPATH 的系統上建置可執行檔等時，會將建置樹狀結構用於 RPATH。當安裝軟體時，CMake 會重新連結可執行檔等，以具有安裝 RPATH。如果此變數設定為 true，則軟體始終以無 RPATH 建置。

  • CMAKE_USE_RELATIVE_PATHS: 使用相對路徑 (可能無法運作！)。

    如果設定為 TRUE，則 CMake 將使用原始檔和二進位樹狀結構之間的相對路徑。此選項不適用於更複雜的專案，並且會在可能的情況下使用相對路徑。一般而言，無論此變數的值為何，都無法將 CMake 產生的 makefile 移動到不同的位置。

  • EXECUTABLE_OUTPUT_PATH: 舊的可執行檔位置變數。

    自 CMake 2.6 起不應再使用此變數。請改用 RUNTIME_OUTPUT_DIRECTORY 目標屬性。如果設定，它會覆寫此變數。

    如果設定，這是建置過程中建置的所有可執行檔將放置的目錄。

  • LIBRARY_OUTPUT_PATH: 舊的函式庫位置變數。

    自 CMake 2.6 起不應再使用此變數。請改用 ARCHIVE_OUTPUT_DIRECTORY、LIBRARY_OUTPUT_DIRECTORY 和 RUNTIME_OUTPUT_DIRECTORY 目標屬性。如果設定，它們會覆寫此變數。

    如果設定，這是建置過程中建置的所有函式庫將放置的目錄。

提供資訊的變數

由 cmake 定義的變數，提供關於專案和 cmake 的資訊

  • CMAKE_AR: 靜態函式庫的歸檔工具名稱。

    指定建立封存檔或靜態函式庫的程式名稱。

  • CMAKE_BINARY_DIR: 建置樹狀結構頂層的路徑。

    這是目前 CMake 建置樹狀結構頂層的完整路徑。對於原始碼內建置，這會與 CMAKE_SOURCE_DIR 相同。

  • CMAKE_BUILD_TOOL: 用於實際建置過程的工具。

    此變數會設定為建置 CMake 輸出所需的程式。如果選取的產生器是 Visual Studio 6，CMAKE_MAKE_PROGRAM 將會設定為 msdev，對於 Unix makefile，它將會設定為 make 或 gmake，對於 Visual Studio 7，它會設定為 devenv。對於 Nmake Makefiles，值為 nmake。這對於根據最終建置環境新增特殊旗標和命令非常有用。

  • CMAKE_CACHEFILE_DIR: 包含 CMakeCache.txt 檔案的目錄。

    這是包含 CMakeCache.txt 檔案的目錄完整路徑。這與 CMAKE_BINARY_DIR 相同。

  • CMAKE_CACHE_MAJOR_VERSION: 用於建立 CMakeCache.txt 檔案的 CMake 主要版本

    這會儲存用於寫入 CMake 快取檔案的 CMake 主要版本。只有當在先前建立的快取檔案上執行不同版本的 CMake 時，才會有所不同。

  • CMAKE_CACHE_MINOR_VERSION: 用於建立 CMakeCache.txt 檔案的 CMake 次要版本

    這會儲存用於寫入 CMake 快取檔案的 CMake 次要版本。只有當在先前建立的快取檔案上執行不同版本的 CMake 時，才會有所不同。

  • CMAKE_CACHE_RELEASE_VERSION: 用於建立 CMakeCache.txt 檔案的 CMake 發行版本

    這會儲存用於寫入 CMake 快取檔案的 CMake 發行版本。只有當在先前建立的快取檔案上執行不同版本的 CMake 時，才會有所不同。

  • CMAKE_CFG_INTDIR: 專案的建置時間組態目錄。

    這是一個變數，用於讓開發人員存取 Visual Studio IDE 專案使用的中繼目錄。例如，如果建置偵錯，所有可執行檔和函式庫都會放在偵錯目錄中。在 UNIX 系統上，此變數會設定為「.」。但是，使用 Visual Studio 時，此變數會設定為 $(IntDir)。$(IntDir) 僅由 IDE 展開。因此，此變數應僅用於在建置過程中執行的自訂命令。此變數不應直接在 CMake 命令中使用。CMake 無法知道 IDE 會選取偵錯還是發行作為建置類型。如果程式需要知道其建置所在的目錄，則可以使用 CMAKE_INTDIR。CMAKE_INTDIR 是一個 C/C++ 前置處理器巨集，定義在編譯器的命令列上。如果它有一個值，則它將是用於建置檔案的中繼目錄。這樣，可執行檔或函式庫就可以找到位於建置目錄中的檔案。

  • CMAKE_COMMAND: cmake 可執行檔的完整路徑。

    這是 CMake 可執行檔 cmake 的完整路徑，對於想要使用 cmake -E 選項進行可攜式系統命令的自訂命令非常有用。（例如 /usr/local/bin/cmake

  • CMAKE_CROSSCOMPILING: CMake 目前是否進行交叉編譯。

    如果 CMake 正在進行交叉編譯，則 CMake 會將此變數設定為 true。特別是當建置平台與目標平台不同時。

  • CMAKE_CTEST_COMMAND: 與 cmake 一起安裝的 ctest 命令的完整路徑。

    這是 CTest 可執行檔 ctest 的完整路徑，對於想要使用 cmake -E 選項進行可攜式系統命令的自訂命令非常有用。

  • CMAKE_CURRENT_BINARY_DIR: 目前正在處理的二進位目錄路徑。

    這是 cmake 目前正在處理的建置目錄完整路徑。add_subdirectory 新增的每個目錄都會在建置樹狀結構中建立一個二進位目錄，並且在處理時會設定此變數。對於原始碼內建置，這是目前正在處理的原始碼目錄。

  • CMAKE_CURRENT_LIST_FILE: 目前正在處理的清單檔案的完整路徑。

    當 CMake 處理專案中的清單檔案時，此變數將始終設定為目前正在處理的清單檔案。另請參閱 CMAKE_PARENT_LIST_FILE。

  • CMAKE_CURRENT_LIST_LINE: 目前正在處理的檔案的行號。

    這是 cmake 目前正在處理的檔案的行號。

  • CMAKE_CURRENT_SOURCE_DIR: 目前正在處理的原始碼目錄路徑。

    這是 cmake 目前正在處理的原始碼目錄完整路徑。

  • CMAKE_DL_LIBS: 包含 dlopen 和 dlclose 的函式庫名稱。

    包含 dlopen 和 dlclose 的函式庫名稱，通常在大多數 UNIX 機器上為 -ldl。

  • CMAKE_EDIT_COMMAND: CMakeSetup 或 ccmake 的完整路徑。

    這是可以圖形化編輯快取的 CMake 可執行檔完整路徑。例如，CMakeSetup、ccmake 或 cmake -i。

  • CMAKE_EXECUTABLE_SUFFIX: 此平台上可執行檔的字尾。

    用於可執行檔結尾的字尾，如果有，Windows 上為 .exe。

  • CMAKE_GENERATOR: 用於建置專案的產生器。

    用於產生建置檔案的產生器名稱。（例如「Unix Makefiles」、「Visual Studio 6」等）

  • CMAKE_HOME_DIRECTORY: 原始碼樹狀結構頂層的路徑。

    這是原始碼樹狀結構頂層的路徑。

  • CMAKE_IMPORT_LIBRARY_PREFIX: 您連結的匯入函式庫的前置詞。

    如果在此平台上使用，則用於匯入函式庫名稱的前置詞。

  • CMAKE_IMPORT_LIBRARY_SUFFIX: 您連結的匯入函式庫的字尾。

    如果在此平台上使用，則用於匯入函式庫結尾的字尾。

  • CMAKE_LINK_LIBRARY_SUFFIX: 您連結的函式庫的字尾。

    用於函式庫結尾的字尾，Windows 上為 .lib。

  • CMAKE_MAJOR_VERSION: cmake 的主要版本（即 2.X.X 中的 2）

    指定正在執行的 CMake 可執行檔的主要版本。

  • CMAKE_MAKE_PROGRAM: 請參閱 CMAKE_BUILD_TOOL。

    此變數是為了向後相容而存在，請參閱 CMAKE_BUILD_TOOL。

  • CMAKE_MINOR_VERSION: cmake 的次要版本（即 X.4.X 中的 4）。

    指定正在執行的 CMake 可執行檔的次要版本。

  • CMAKE_PARENT_LIST_FILE: 目前正在處理的清單檔案的父清單檔案完整路徑。

    當 CMake 處理專案中的清單檔案時，此變數將始終設定為包含或以某種方式調用目前正在處理的清單檔案的清單檔案。另請參閱 CMAKE_CURRENT_LIST_FILE。

  • CMAKE_PATCH_VERSION: cmake 的修補程式版本（即 X.X.3 中的 3）。

    指定正在執行的 CMake 可執行檔的修補程式版本。

  • CMAKE_PROJECT_NAME: 目前專案的名稱。

    指定來自最近繼承的 PROJECT 命令的目前專案名稱。

  • CMAKE_RANLIB: 靜態函式庫的隨機化工具名稱。

    指定在 UNIX 上隨機化函式庫的程式名稱，在 Windows 上未使用，但可能存在。

  • CMAKE_ROOT: 執行 cmake 的安裝目錄。

    這是執行 CMake 的安裝根目錄，並且可以在此處找到 Modules 目錄。這通常以以下格式使用：${CMAKE_ROOT}/Modules

  • CMAKE_SHARED_LIBRARY_PREFIX: 您連結的共享函式庫的前置詞。

    用於共享函式庫名稱的前置詞，UNIX 上為 lib。

  • CMAKE_SHARED_LIBRARY_SUFFIX: 您連結的共享函式庫的字尾。

    用於共享函式庫結尾的字尾，Windows 上為 .dll。

  • CMAKE_SHARED_MODULE_PREFIX: 您連結的可載入模組的前置詞。

    用於此平台上可載入模組名稱的前置詞。

  • CMAKE_SHARED_MODULE_SUFFIX: 您連結的共享函式庫的字尾。

    用於此平台上可載入模組結尾的字尾。

  • CMAKE_SIZEOF_VOID_P: void 指標的大小。

    這會設定為機器上指標的大小，並且由嘗試編譯確定。如果找到 64 位元大小，則會修改函式庫搜尋路徑，以先搜尋 64 位元函式庫。

  • CMAKE_SKIP_RPATH: 如果為 true，則不要新增執行時間路徑資訊。

    如果將此設定為 TRUE，則不會將 rpath 資訊新增到已編譯的可執行檔。預設值是在平台支援的情況下新增 rpath 資訊。這允許從建置樹狀結構輕鬆執行。

  • CMAKE_SOURCE_DIR: 原始碼樹狀結構頂層的路徑。

    這是目前 CMake 原始碼樹狀結構頂層的完整路徑。對於原始碼內建置，這會與 CMAKE_BINARY_DIR 相同。

  • CMAKE_STANDARD_LIBRARIES: 連結到每個可執行檔和共享函式庫的函式庫。

    這是連結到所有可執行檔和函式庫的函式庫清單。

  • CMAKE_STATIC_LIBRARY_PREFIX: 您連結的靜態函式庫的前置詞。

    用於靜態函式庫名稱的前綴，在 UNIX 系統上為 lib。

  • CMAKE_STATIC_LIBRARY_SUFFIX: 靜態函式庫的後綴，用於連結時。

    用於靜態函式庫結尾的後綴，在 Windows 系統上為 .lib。

  • CMAKE_USING_VC_FREE_TOOLS: 若使用 Visual Studio 免費工具則為 True。

    如果編譯器是 Visual Studio 免費工具，則此變數會設為 true。

  • CMAKE_VERBOSE_MAKEFILE: 若啟用，則建立詳細的 makefile。

    此變數預設為 false。您可以將此變數設為 true，讓 CMake 產生詳細的 makefile，顯示每個使用的命令列。

  • CMAKE_VERSION: CMake 的完整版本，格式為 major.minor.patch。

    這指定了正在執行的 CMake 可執行檔的完整版本。此變數定義於 2.6.3 及更高版本。請參閱變數 CMAKE_MAJOR_VERSION、CMAKE_MINOR_VERSION 和 CMAKE_PATCH_VERSION 以取得個別的版本組件。

  • PROJECT_BINARY_DIR: 專案的建置目錄完整路徑。

    這是最近一次 PROJECT 命令的二進位目錄。

  • PROJECT_NAME: 給予 project 命令的專案名稱。

    這是最近一次 PROJECT 命令所給予的名稱。

  • PROJECT_SOURCE_DIR: 目前專案的頂層原始碼目錄。

    這是最近一次 PROJECT 命令的原始碼目錄。

  • [專案名稱]_BINARY_DIR: 指定專案名稱的頂層二進位目錄。

    會建立一個變數，其名稱使用於 PROJECT 命令中，且為專案的二進位目錄。當使用 SUBDIR 來連接多個專案時，這會很有用。

  • [專案名稱]_SOURCE_DIR: 指定專案名稱的頂層原始碼目錄。

    會建立一個變數，其名稱使用於 PROJECT 命令中，且為專案的原始碼目錄。當使用 add_subdirectory 來連接多個專案時，這會很有用。

版權

版權所有 (c) 2002 Kitware, Inc., Insight Consortium。保留所有權利。

在符合下列條件下，允許以原始碼和二進位形式重新發布和使用，無論是否修改：

原始碼的重新發布必須保留上述版權聲明、此條件清單和以下免責聲明。

二進位形式的重新發布必須在隨發布提供的文件和/或其他資料中重製上述版權聲明、此條件清單和以下免責聲明。

未經事先明確書面許可，不得使用 Kitware, Inc.、Insight Consortium 的名稱，或任何聯盟成員或任何貢獻者的名稱，來背書或推廣衍生自本軟體的產品。

修改過的原始碼版本必須明確標記，且不得虛報為原始軟體。

本軟體由版權持有者和貢獻者按「現狀」提供，且不作任何明示或暗示的擔保，包括但不限於適銷性和特定用途適用性的暗示擔保。在任何情況下，作者或貢獻者均不對任何直接、間接、附帶、特殊、懲罰性或後果性損害（包括但不限於替代商品或服務的採購；使用、資料或利潤的損失；或業務中斷）負責，無論其如何造成，以及根據任何責任理論（無論是合約、嚴格責任或侵權行為（包括疏忽或其他））造成的，即使已被告知發生此類損害的可能性。

參閱

以下資源可用於取得使用 CMake 的相關幫助

實用連結摘要

  Home: http://www.cmake.org
  Docs: http://www.cmake.org/HTML/Documentation.html
  Mail: http://www.cmake.org/HTML/MailingLists.html
  FAQ:  http://www.cmake.org/Wiki/CMake_FAQ